diff --git a/libcxx/docs/Status/Cxx2bPapers.csv b/libcxx/docs/Status/Cxx2bPapers.csv
--- a/libcxx/docs/Status/Cxx2bPapers.csv
+++ b/libcxx/docs/Status/Cxx2bPapers.csv
@@ -41,7 +41,7 @@
 "`P0323R12 <https://wg21.link/P0323R12>`__","LWG","``std::expected``","February 2022","|Complete|","16.0"
 "`P0533R9 <https://wg21.link/P0533R9>`__","LWG","``constexpr`` for ``<cmath>`` and ``<cstdlib>``","February 2022","|In progress| [#note-P0533R9]_",""
 "`P0627R6 <https://wg21.link/P0627R6>`__","LWG","Function to mark unreachable code","February 2022","|Complete|","15.0"
-"`P1206R7 <https://wg21.link/P1206R7>`__","LWG","``ranges::to``: A function to convert any range to a container","February 2022","","","|ranges|"
+"`P1206R7 <https://wg21.link/P1206R7>`__","LWG","``ranges::to``: A function to convert any range to a container","February 2022","|In Progress|","","|ranges|"
 "`P1413R3 <https://wg21.link/P1413R3>`__","LWG","Deprecate ``std::aligned_storage`` and ``std::aligned_union``","February 2022","|Complete| [#note-P1413R3]_",""
 "`P2255R2 <https://wg21.link/P2255R2>`__","LWG","A type trait to detect reference binding to temporary","February 2022","",""
 "`P2273R3 <https://wg21.link/P2273R3>`__","LWG","Making ``std::unique_ptr`` constexpr","February 2022","|Complete|","16.0"
diff --git a/libcxx/include/__ranges/container_compatible_range.h b/libcxx/include/__ranges/container_compatible_range.h
new file mode 100644
--- /dev/null
+++ b/libcxx/include/__ranges/container_compatible_range.h
@@ -0,0 +1,33 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___RANGES_CONTAINER_COMPATIBLE_RANGE_H
+#define _LIBCPP___RANGES_CONTAINER_COMPATIBLE_RANGE_H
+
+#include <__config>
+#include <__concepts/convertible_to.h>
+#include <__ranges/concepts.h>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+#if _LIBCPP_STD_VER >= 23
+
+template <class _Range, class _Tp>
+concept _ContainerCompatibleRange =
+  ranges::input_range<_Range> && convertible_to<ranges::range_reference_t<_Range>, _Tp>;
+
+#endif // _LIBCPP_STD_VER >= 23
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP___RANGES_CONTAINER_COMPATIBLE_RANGE_H
diff --git a/libcxx/include/__ranges/from_range.h b/libcxx/include/__ranges/from_range.h
new file mode 100644
--- /dev/null
+++ b/libcxx/include/__ranges/from_range.h
@@ -0,0 +1,33 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___RANGES_FROM_RANGE_H
+#define _LIBCPP___RANGES_FROM_RANGE_H
+
+#include <__config>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+#if _LIBCPP_STD_VER >= 23
+
+struct from_range_t {
+  _LIBCPP_HIDE_FROM_ABI explicit from_range_t() = default;
+};
+
+inline constexpr from_range_t from_range{};
+
+#endif // _LIBCPP_STD_VER >= 23
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP___RANGES_FROM_RANGE_H
diff --git a/libcxx/include/string b/libcxx/include/string
--- a/libcxx/include/string
+++ b/libcxx/include/string
@@ -124,6 +124,8 @@
     template<class InputIterator>
         basic_string(InputIterator begin, InputIterator end,
                      const allocator_type& a = allocator_type());                               // constexpr since C++20
+    template<container-compatible-range<charT> R>
+      constexpr basic_string(from_range_t, R&& rg, const Allocator& a = Allocator());           // since C++23
     basic_string(initializer_list<value_type>, const Allocator& = Allocator());                 // constexpr since C++20
     basic_string(const basic_string&, const Allocator&);                                        // constexpr since C++20
     basic_string(basic_string&&, const Allocator&);                                             // constexpr since C++20
@@ -200,6 +202,8 @@
     basic_string& append(size_type n, value_type c);                                            // constexpr since C++20
     template<class InputIterator>
         basic_string& append(InputIterator first, InputIterator last);                          // constexpr since C++20
+    template<container-compatible-range<charT> R>
+      constexpr basic_string& append_range(R&& rg);                                             // C++23
     basic_string& append(initializer_list<value_type>);                                         // constexpr since C++20
 
     void push_back(value_type c);                                                               // constexpr since C++20
@@ -221,6 +225,8 @@
     basic_string& assign(size_type n, value_type c);                                            // constexpr since C++20
     template<class InputIterator>
         basic_string& assign(InputIterator first, InputIterator last);                          // constexpr since C++20
+    template<container-compatible-range<charT> R>
+      constexpr basic_string& assign_range(R&& rg);                                             // C++23
     basic_string& assign(initializer_list<value_type>);                                         // constexpr since C++20
 
     basic_string& insert(size_type pos1, const basic_string& str);                              // constexpr since C++20
@@ -237,6 +243,8 @@
     iterator      insert(const_iterator p, size_type n, value_type c);                          // constexpr since C++20
     template<class InputIterator>
         iterator insert(const_iterator p, InputIterator first, InputIterator last);             // constexpr since C++20
+    template<container-compatible-range<charT> R>
+      constexpr iterator insert_range(const_iterator p, R&& rg);                                // C++23
     iterator      insert(const_iterator p, initializer_list<value_type>);                       // constexpr since C++20
 
     basic_string& erase(size_type pos = 0, size_type n = npos);                                 // constexpr since C++20
@@ -262,6 +270,8 @@
     basic_string& replace(const_iterator i1, const_iterator i2, size_type n, value_type c);     // constexpr since C++20
     template<class InputIterator>
         basic_string& replace(const_iterator i1, const_iterator i2, InputIterator j1, InputIterator j2); // constexpr since C++20
+    template<container-compatible-range<charT> R>
+      constexpr basic_string& replace_with_range(const_iterator i1, const_iterator i2, R&& rg); // C++23
     basic_string& replace(const_iterator i1, const_iterator i2, initializer_list<value_type>);  // constexpr since C++20
 
     size_type copy(value_type* s, size_type n, size_type pos = 0) const;                        // constexpr since C++20
@@ -354,6 +364,26 @@
                   char_traits<typename iterator_traits<InputIterator>::value_type>,
                   Allocator>;   // C++17
 
+template<ranges::input_range R,
+         class Allocator = allocator<ranges::range_value_t<R>>>
+  basic_string(from_range_t, R&&, Allocator = Allocator())
+    -> basic_string<ranges::range_value_t<R>, char_traits<ranges::range_value_t<R>>,
+                    Allocator>; // C++23
+
+template<class charT,
+         class traits,
+         class Allocator = allocator<charT>>
+  explicit basic_string(basic_string_view<charT, traits>, const Allocator& = Allocator())
+    -> basic_string<charT, traits, Allocator>; // C++17
+
+template<class charT,
+         class traits,
+         class Allocator = allocator<charT>>
+  basic_string(basic_string_view<charT, traits>,
+                typename see below::size_type, typename see below::size_type,
+                const Allocator& = Allocator())
+    -> basic_string<charT, traits, Allocator>; // C++17
+
 template<class charT, class traits, class Allocator>
 basic_string<charT, traits, Allocator>
 operator+(const basic_string<charT, traits, Allocator>& lhs,
@@ -559,6 +589,11 @@
 #include <__memory/pointer_traits.h>
 #include <__memory/swap_allocator.h>
 #include <__memory_resource/polymorphic_allocator.h>
+#include <__ranges/access.h>
+#include <__ranges/concepts.h>
+#include <__ranges/container_compatible_range.h>
+#include <__ranges/from_range.h>
+#include <__ranges/size.h>
 #include <__string/char_traits.h>
 #include <__string/extern_template_lists.h>
 #include <__type_traits/is_allocator.h>
@@ -660,6 +695,8 @@
 
 struct __uninitialized_size_tag {};
 
+struct __init_with_sentinel_tag {};
+
 template<class _CharT, class _Traits, class _Allocator>
 class basic_string
 {
@@ -820,6 +857,14 @@
         std::__debug_db_insert_c(this);
     }
 
+    template <class _Iter, class _Sent>
+    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
+    basic_string(__init_with_sentinel_tag, _Iter __first, _Sent __last, const allocator_type& __a)
+        : __r_(__default_init_tag(), __a) {
+      __init_with_sentinel(__first, __last);
+      std::__debug_db_insert_c(this);
+    }
+
     _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 iterator __make_iterator(pointer __p) {
         return iterator(this, __p);
     }
@@ -1046,6 +1091,21 @@
     std::__debug_db_insert_c(this);
   }
 
+#if _LIBCPP_STD_VER >= 23
+  template <_ContainerCompatibleRange<_CharT> _Range>
+  _LIBCPP_HIDE_FROM_ABI constexpr
+  basic_string(from_range_t, _Range&& __range, const allocator_type& __a = allocator_type())
+      : __r_(__default_init_tag(), __a) {
+    if constexpr (ranges::forward_range<_Range> || ranges::sized_range<_Range>) {
+      __init_with_size(ranges::begin(__range), ranges::end(__range), ranges::distance(__range));
+    } else {
+      __init_with_sentinel(ranges::begin(__range), ranges::end(__range));
+    }
+
+    std::__debug_db_insert_c(this);
+  }
+#endif
+
 #ifndef _LIBCPP_CXX03_LANG
   _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string(initializer_list<_CharT> __il)
       : __r_(__default_init_tag(), __default_init_tag()) {
@@ -1259,6 +1319,14 @@
     _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string&
     append(_ForwardIterator __first, _ForwardIterator __last);
 
+#if _LIBCPP_STD_VER >= 23
+    template <_ContainerCompatibleRange<_CharT> _Range>
+    _LIBCPP_HIDE_FROM_ABI
+    constexpr basic_string& append_range(_Range&& __range) {
+      return append(basic_string(from_range, std::forward<_Range>(__range), get_allocator()));
+    }
+#endif
+
 #ifndef _LIBCPP_CXX03_LANG
     _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
     basic_string& append(initializer_list<value_type> __il) {return append(__il.begin(), __il.size());}
@@ -1322,6 +1390,24 @@
     _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS _LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string&
     assign(_ForwardIterator __first, _ForwardIterator __last);
 
+#if _LIBCPP_STD_VER >= 23
+    template <_ContainerCompatibleRange<_CharT> _Range>
+    _LIBCPP_HIDE_FROM_ABI
+    constexpr basic_string& assign_range(_Range&& __range) {
+      if constexpr (ranges::forward_range<_Range> || ranges::sized_range<_Range>) {
+        size_type __n = __string_is_trivial_iterator<ranges::iterator_t<_Range>>::value ?
+            static_cast<size_type>(ranges::distance(__range)) : 0;
+        __assign_with_size(ranges::begin(__range), ranges::end(__range), __n);
+
+      } else {
+        basic_string __temp(from_range, std::forward<_Range>(__range), __alloc());
+        assign(__temp.data(), __temp.size());
+      }
+
+      return *this;
+    }
+#endif
+
 #ifndef _LIBCPP_CXX03_LANG
     _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
     basic_string& assign(initializer_list<value_type> __il) {return assign(__il.begin(), __il.size());}
@@ -1353,6 +1439,21 @@
   _LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string& insert(size_type __pos, size_type __n, value_type __c);
   _LIBCPP_CONSTEXPR_SINCE_CXX20 iterator insert(const_iterator __pos, value_type __c);
 
+#if _LIBCPP_STD_VER >= 23
+    template <_ContainerCompatibleRange<_CharT> _Range>
+    _LIBCPP_HIDE_FROM_ABI
+    constexpr iterator insert_range(const_iterator __position, _Range&& __range) {
+      if constexpr (ranges::forward_range<_Range> || ranges::sized_range<_Range>) {
+        auto __n = static_cast<size_type>(ranges::distance(__range));
+        return __insert_with_size(__position, ranges::begin(__range), ranges::end(__range), __n);
+
+      } else {
+        basic_string __temp(from_range, std::forward<_Range>(__range), __alloc());
+        return insert(__position, __temp.data(), __temp.data() + __temp.size());
+      }
+    }
+#endif
+
   _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 iterator
   insert(const_iterator __pos, size_type __n, value_type __c) {
     _LIBCPP_DEBUG_ASSERT(__get_const_db()->__find_c_from_i(&__pos) == this,
@@ -1441,6 +1542,15 @@
   _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS _LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string&
   replace(const_iterator __i1, const_iterator __i2, _InputIterator __j1, _InputIterator __j2);
 
+#if _LIBCPP_STD_VER >= 23
+    template <_ContainerCompatibleRange<_CharT> _Range>
+    _LIBCPP_HIDE_FROM_ABI
+    constexpr basic_string& replace_with_range(const_iterator __i1, const_iterator __i2, _Range&& __range) {
+      basic_string __temp(from_range, std::forward<_Range>(__range), __alloc());
+      return replace(__i1, __i2, __temp);
+    }
+#endif
+
 #ifndef _LIBCPP_CXX03_LANG
     _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
     basic_string& replace(const_iterator __i1, const_iterator __i2, initializer_list<value_type> __il)
@@ -1699,9 +1809,17 @@
         return !__libcpp_is_constant_evaluated() && (__sz < __min_cap);
     }
 
-    template <class _ForwardIterator>
+    template <class _Iterator, class _Sentinel>
+    _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI
+    void __assign_with_size(_Iterator __first, _Sentinel __last, size_type __n);
+
+    template <class _Iterator, class _Sentinel>
+    _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI
+    void __assign_with_sentinel(_Iterator __first, _Sentinel __last);
+
+    template <class _ForwardIterator, class _Sentinel>
     _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14
-    iterator __insert_from_safe_copy(size_type __n, size_type __ip, _ForwardIterator __first, _ForwardIterator __last) {
+    iterator __insert_from_safe_copy(size_type __n, size_type __ip, _ForwardIterator __first, _Sentinel __last) {
         size_type __sz = size();
         size_type __cap = capacity();
         value_type* __p;
@@ -1726,6 +1844,10 @@
         return begin() + __ip;
     }
 
+    template<class _Iterator, class _Sentinel>
+    _LIBCPP_CONSTEXPR_SINCE_CXX20
+    iterator __insert_with_size(const_iterator __pos, _Iterator __first, _Sentinel __last, size_type __n);
+
     _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 allocator_type& __alloc() _NOEXCEPT { return __r_.second(); }
     _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR const allocator_type& __alloc() const _NOEXCEPT { return __r_.second(); }
 
@@ -1828,6 +1950,13 @@
     template <class _ForwardIterator, __enable_if_t<__is_cpp17_forward_iterator<_ForwardIterator>::value, int> = 0>
     inline _LIBCPP_CONSTEXPR_SINCE_CXX20 void __init(_ForwardIterator __first, _ForwardIterator __last);
 
+    template <class _InputIterator, class _Sentinel>
+    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
+    void __init_with_sentinel(_InputIterator __first, _Sentinel __last);
+    template <class _InputIterator, class _Sentinel>
+    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
+    void __init_with_size(_InputIterator __first, _Sentinel __last, size_type __sz);
+
     _LIBCPP_CONSTEXPR_SINCE_CXX20
     void __grow_by(size_type __old_cap, size_type __delta_cap, size_type __old_sz,
                    size_type __n_copy,  size_type __n_del,     size_type __n_add = 0);
@@ -2014,6 +2143,15 @@
   -> basic_string<_CharT, _Traits, _Allocator>;
 #endif
 
+#if _LIBCPP_STD_VER >= 23
+template <ranges::input_range _Range,
+          class _Allocator = allocator<ranges::range_value_t<_Range>>,
+          class = enable_if_t<__is_allocator<_Allocator>::value>
+          >
+basic_string(from_range_t, _Range&&, _Allocator = _Allocator())
+  -> basic_string<ranges::range_value_t<_Range>, char_traits<ranges::range_value_t<_Range>>, _Allocator>;
+#endif
+
 template <class _CharT, class _Traits, class _Allocator>
 inline _LIBCPP_CONSTEXPR_SINCE_CXX20
 void
@@ -2159,7 +2297,15 @@
 _LIBCPP_CONSTEXPR_SINCE_CXX20
 void basic_string<_CharT, _Traits, _Allocator>::__init(_InputIterator __first, _InputIterator __last)
 {
+  __init_with_sentinel(__first, __last);
+}
+
+template <class _CharT, class _Traits, class _Allocator>
+template <class _InputIterator, class _Sentinel>
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
+void basic_string<_CharT, _Traits, _Allocator>::__init_with_sentinel(_InputIterator __first, _Sentinel __last) {
     __default_init();
+
 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
     try
     {
@@ -2182,16 +2328,27 @@
 _LIBCPP_CONSTEXPR_SINCE_CXX20 void
 basic_string<_CharT, _Traits, _Allocator>::__init(_ForwardIterator __first, _ForwardIterator __last)
 {
+  size_type __sz = static_cast<size_type>(std::distance(__first, __last));
+  __init_with_size(__first, __last, __sz);
+}
+
+template <class _CharT, class _Traits, class _Allocator>
+template <class _InputIterator, class _Sentinel>
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
+void basic_string<_CharT, _Traits, _Allocator>::__init_with_size(
+    _InputIterator __first, _Sentinel __last, size_type __sz) {
     if (__libcpp_is_constant_evaluated())
         __r_.first() = __rep();
-    size_type __sz = static_cast<size_type>(std::distance(__first, __last));
+
     if (__sz > max_size())
         __throw_length_error();
+
     pointer __p;
     if (__fits_in_sso(__sz))
     {
         __set_short_size(__sz);
         __p = __get_short_pointer();
+
     }
     else
     {
@@ -2447,9 +2604,17 @@
 _LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string<_CharT, _Traits, _Allocator>&
 basic_string<_CharT, _Traits, _Allocator>::assign(_InputIterator __first, _InputIterator __last)
 {
-    const basic_string __temp(__first, __last, __alloc());
-    assign(__temp.data(), __temp.size());
-    return *this;
+  __assign_with_sentinel(__first, __last);
+  return *this;
+}
+
+template <class _CharT, class _Traits, class _Allocator>
+template <class _InputIterator, class _Sentinel>
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
+void
+basic_string<_CharT, _Traits, _Allocator>::__assign_with_sentinel(_InputIterator __first, _Sentinel __last) {
+  const basic_string __temp(__init_with_sentinel_tag{}, __first, __last, __alloc());
+  assign(__temp.data(), __temp.size());
 }
 
 template <class _CharT, class _Traits, class _Allocator>
@@ -2457,11 +2622,24 @@
 _LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string<_CharT, _Traits, _Allocator>&
 basic_string<_CharT, _Traits, _Allocator>::assign(_ForwardIterator __first, _ForwardIterator __last)
 {
+  if (__string_is_trivial_iterator<_ForwardIterator>::value) {
+      size_type __n = static_cast<size_type>(std::distance(__first, __last));
+    __assign_with_size(__first, __last, __n);
+  } else {
+    __assign_with_sentinel(__first, __last);
+  }
+
+  return *this;
+}
+
+template <class _CharT, class _Traits, class _Allocator>
+template <class _Iterator, class _Sentinel>
+_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI
+void
+basic_string<_CharT, _Traits, _Allocator>::__assign_with_size(_Iterator __first, _Sentinel __last, size_type __n) {
     size_type __cap = capacity();
-    size_type __n = __string_is_trivial_iterator<_ForwardIterator>::value ?
-        static_cast<size_type>(std::distance(__first, __last)) : 0;
 
-    if (__string_is_trivial_iterator<_ForwardIterator>::value &&
+    if (__string_is_trivial_iterator<_Iterator>::value &&
         (__cap >= __n || !__addr_in_range(*__first)))
     {
         if (__cap < __n)
@@ -2478,10 +2656,8 @@
     }
     else
     {
-        const basic_string __temp(__first, __last, __alloc());
-        assign(__temp.data(), __temp.size());
+      __assign_with_sentinel(__first, __last);
     }
-    return *this;
 }
 
 template <class _CharT, class _Traits, class _Allocator>
@@ -2787,19 +2963,27 @@
 {
     _LIBCPP_DEBUG_ASSERT(__get_const_db()->__find_c_from_i(&__pos) == this,
                          "string::insert(iterator, range) called with an iterator not referring to this string");
+    auto __n = static_cast<size_type>(std::distance(__first, __last));
+    return __insert_with_size(__pos, __first, __last, __n);
+}
 
+template <class _CharT, class _Traits, class _Allocator>
+template<class _Iterator, class _Sentinel>
+_LIBCPP_CONSTEXPR_SINCE_CXX20
+typename basic_string<_CharT, _Traits, _Allocator>::iterator
+basic_string<_CharT, _Traits, _Allocator>::__insert_with_size(
+    const_iterator __pos, _Iterator __first, _Sentinel __last, size_type __n) {
     size_type __ip = static_cast<size_type>(__pos - begin());
-    size_type __n = static_cast<size_type>(std::distance(__first, __last));
     if (__n == 0)
         return begin() + __ip;
 
-    if (__string_is_trivial_iterator<_ForwardIterator>::value && !__addr_in_range(*__first))
+    if (__string_is_trivial_iterator<_Iterator>::value && !__addr_in_range(*__first))
     {
         return __insert_from_safe_copy(__n, __ip, __first, __last);
     }
     else
     {
-        const basic_string __temp(__first, __last, __alloc());
+        const basic_string __temp(__init_with_sentinel_tag{}, __first, __last, __alloc());
         return __insert_from_safe_copy(__n, __ip, __temp.begin(), __temp.end());
     }
 }
diff --git a/libcxx/test/std/containers/from_range_helpers.h b/libcxx/test/std/containers/from_range_helpers.h
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/containers/from_range_helpers.h
@@ -0,0 +1,148 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef SUPPORT_FROM_RANGE_HELPERS_H
+#define SUPPORT_FROM_RANGE_HELPERS_H
+
+#include <cstddef>
+#include <iterator>
+#include <type_traits>
+
+#include "min_allocator.h"
+#include "test_allocator.h"
+#include "test_iterators.h"
+#include "test_macros.h"
+#include "type_algorithms.h"
+
+struct Empty {};
+
+template <class T>
+struct InputRange {
+  cpp20_input_iterator<T*> begin();
+  sentinel_wrapper<cpp20_input_iterator<T*>> end();
+};
+
+template <class Iter, class Sent, std::ranges::input_range Range>
+constexpr auto wrap_input(Range&& input) {
+  auto b = Iter(std::ranges::begin(input));
+  auto e = Sent(Iter(std::ranges::end(input)));
+  return std::ranges::subrange(std::move(b), std::move(e));
+}
+
+template <class Iter, class Sent, class T>
+constexpr auto wrap_input(std::vector<T>& input) {
+  auto b = Iter(input.data());
+  auto e = Sent(Iter(input.data() + input.size()));
+  return std::ranges::subrange(std::move(b), std::move(e));
+}
+
+struct KeyValue {
+  int key; // Only the key is considered for equality comparison.
+  char value; // Allows distinguishing equivalent instances.
+
+  bool operator<(const KeyValue& other) const { return key < other.key; }
+  bool operator==(const KeyValue& other) const { return key == other.key; }
+};
+
+template <>
+struct std::hash<KeyValue> {
+  std::size_t operator()(const KeyValue& kv) const {
+    return kv.key;
+  }
+};
+
+#if !defined(TEST_HAS_NO_EXCEPTIONS)
+template <int N>
+struct ThrowingCopy {
+  static bool throwing_enabled;
+  static int created_by_copying;
+  static int destroyed;
+  int x = 0; // Allows distinguishing between different instances.
+
+  ThrowingCopy() = default;
+  ThrowingCopy(int value) : x(value) {}
+  ~ThrowingCopy() {
+    ++destroyed;
+  }
+
+  ThrowingCopy(const ThrowingCopy& other) : x(other.x) {
+    ++created_by_copying;
+    if (throwing_enabled && created_by_copying == N) {
+      throw -1;
+    }
+  }
+
+  friend auto operator<=>(const ThrowingCopy&, const ThrowingCopy&) = default;
+
+  static void reset() {
+    created_by_copying = destroyed = 0;
+  }
+};
+
+template <int N>
+struct std::hash<ThrowingCopy<N>> {
+  std::size_t operator()(const ThrowingCopy<N>& value) const {
+    return value.x;
+  }
+};
+
+template <int N>
+bool ThrowingCopy<N>::throwing_enabled = true;
+template <int N>
+int ThrowingCopy<N>::created_by_copying = 0;
+template <int N>
+int ThrowingCopy<N>::destroyed = 0;
+
+template <class T>
+struct ThrowingAllocator {
+  using value_type = T;
+  using char_type = T;
+  using is_always_equal = std::false_type;
+
+  ThrowingAllocator() = default;
+
+  template <class U>
+  ThrowingAllocator(const ThrowingAllocator<U>&) {}
+
+  T* allocate(std::size_t) { throw 1; }
+  void deallocate(T*, std::size_t) {}
+
+  template <class U>
+  friend bool operator==(const ThrowingAllocator&, const ThrowingAllocator<U>&) {
+    return true;
+  }
+};
+#endif
+
+template <class T, class Func>
+constexpr void for_all_iterators_and_allocators(Func f) {
+  using Iterators = types::type_list<
+    cpp20_input_iterator<T*>,
+    forward_iterator<T*>,
+    bidirectional_iterator<T*>,
+    random_access_iterator<T*>,
+    contiguous_iterator<T*>,
+    T*
+  >;
+
+  types::for_each(Iterators{}, [=]<class Iter>() {
+    f.template operator()<Iter, sentinel_wrapper<Iter>, std::allocator<T>>();
+    f.template operator()<Iter, sentinel_wrapper<Iter>, test_allocator<T>>();
+    f.template operator()<Iter, sentinel_wrapper<Iter>, min_allocator<T>>();
+    f.template operator()<Iter, sentinel_wrapper<Iter>, safe_allocator<T>>();
+
+    if constexpr (std::sentinel_for<Iter, Iter>) {
+      f.template operator()<Iter, Iter, std::allocator<T>>();
+      f.template operator()<Iter, Iter, test_allocator<T>>();
+      f.template operator()<Iter, Iter, min_allocator<T>>();
+      f.template operator()<Iter, Iter, safe_allocator<T>>();
+    }
+  });
+}
+
+#endif // SUPPORT_FROM_RANGE_HELPERS_H
diff --git a/libcxx/test/std/containers/insert_range_helpers.h b/libcxx/test/std/containers/insert_range_helpers.h
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/containers/insert_range_helpers.h
@@ -0,0 +1,123 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef SUPPORT_INSERT_RANGE_HELPERS_H
+#define SUPPORT_INSERT_RANGE_HELPERS_H
+
+#include <algorithm>
+#include <array>
+#include <cassert>
+#include <concepts>
+#include <map>
+#include <ranges>
+#include <set>
+#include <type_traits>
+#include <unordered_map>
+#include <unordered_set>
+#include <vector>
+
+#include "from_range_helpers.h"
+#include "min_allocator.h"
+#include "test_allocator.h"
+#include "test_iterators.h"
+#include "test_macros.h"
+#include "type_algorithms.h"
+
+// A simple literal-type container. It can be used as a `constexpr` global variable (which isn't supported by
+// `std::vector`).
+template <class T, std::size_t N = 32>
+class Buffer {
+ public:
+  constexpr Buffer() = default;
+
+  constexpr Buffer(std::initializer_list<T> input) {
+    assert(input.size() <= N);
+    std::ranges::copy(input, data_);
+    size_ = input.size();
+  }
+
+  // Makes initializing `Buffer<char>` nicer -- allows writing `buf = "abc"` instead of `buf = {'a', 'b', 'c'}`.
+  // To make the two forms equivalent, omits the terminating null.
+  template <std::size_t N2>
+  constexpr Buffer(const char (&input) [N2])
+  requires std::same_as<T, char> {
+    static_assert(N2 <= N);
+    std::ranges::copy(input, data_);
+    // Omit the terminating null.
+    size_ = input[N2 - 1] == '\0' ? N2 - 1 : N2;
+  }
+
+  constexpr const T* begin() const { return data_; }
+  constexpr const T* end() const { return data_ + size_; }
+  constexpr std::size_t size() const { return size_; }
+
+ private:
+  std::size_t size_ = 0;
+  T data_[N] = {};
+};
+
+template <class T>
+struct TestCase {
+  Buffer<T> initial;
+  std::size_t index = 0;
+  Buffer<T> input;
+  Buffer<T> expected;
+};
+
+template <class T, class PtrT, class Func>
+constexpr void for_all_iterators_and_allocators(Func f) {
+  using Iterators = types::type_list<
+    cpp20_input_iterator<PtrT>,
+    forward_iterator<PtrT>,
+    bidirectional_iterator<PtrT>,
+    random_access_iterator<PtrT>,
+    contiguous_iterator<PtrT>,
+    PtrT
+  >;
+
+  types::for_each(Iterators{}, [=]<class Iter>() {
+    f.template operator()<Iter, sentinel_wrapper<Iter>, std::allocator<T>>();
+    f.template operator()<Iter, sentinel_wrapper<Iter>, test_allocator<T>>();
+    f.template operator()<Iter, sentinel_wrapper<Iter>, min_allocator<T>>();
+    f.template operator()<Iter, sentinel_wrapper<Iter>, safe_allocator<T>>();
+
+    if constexpr (std::sentinel_for<Iter, Iter>) {
+      f.template operator()<Iter, Iter, std::allocator<T>>();
+      f.template operator()<Iter, Iter, test_allocator<T>>();
+      f.template operator()<Iter, Iter, min_allocator<T>>();
+      f.template operator()<Iter, Iter, safe_allocator<T>>();
+    }
+  });
+}
+
+// Uses a shorter list of iterator types for use in `constexpr` mode for cases when running the full set in would take
+// too long.
+template <class T, class PtrT, class Func>
+constexpr void for_all_iterators_and_allocators_constexpr(Func f) {
+  using Iterators = types::type_list<
+    cpp20_input_iterator<PtrT>,
+    forward_iterator<PtrT>,
+    PtrT
+  >;
+
+  types::for_each(Iterators{}, [=]<class Iter>() {
+    f.template operator()<Iter, sentinel_wrapper<Iter>, std::allocator<T>>();
+    f.template operator()<Iter, sentinel_wrapper<Iter>, test_allocator<T>>();
+    f.template operator()<Iter, sentinel_wrapper<Iter>, min_allocator<T>>();
+    f.template operator()<Iter, sentinel_wrapper<Iter>, safe_allocator<T>>();
+
+    if constexpr (std::sentinel_for<Iter, Iter>) {
+      f.template operator()<Iter, Iter, std::allocator<T>>();
+      f.template operator()<Iter, Iter, test_allocator<T>>();
+      f.template operator()<Iter, Iter, min_allocator<T>>();
+      f.template operator()<Iter, Iter, safe_allocator<T>>();
+    }
+  });
+}
+
+#endif // SUPPORT_INSERT_RANGE_HELPERS_H
diff --git a/libcxx/test/std/containers/sequences/from_range_sequence_containers.h b/libcxx/test/std/containers/sequences/from_range_sequence_containers.h
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/containers/sequences/from_range_sequence_containers.h
@@ -0,0 +1,161 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef SUPPORT_FROM_RANGE_SEQUENCE_CONTAINERS_H
+#define SUPPORT_FROM_RANGE_SEQUENCE_CONTAINERS_H
+
+#include <algorithm>
+#include <array>
+#include <cassert>
+#include <cstddef>
+#include <iterator>
+#include <ranges>
+#include <utility>
+
+#include "../from_range_helpers.h"
+#include "MoveOnly.h"
+#include "almost_satisfies_types.h"
+#include "count_new.h"
+#include "test_iterators.h"
+#include "test_macros.h"
+
+template <class T>
+concept HasSize = requires (const T& value) { value.size(); };
+
+template <class Container, class Range>
+concept HasFromRangeCtr = requires (Range&& range) {
+  Container(std::from_range, std::forward<Range>(range));
+  Container(std::from_range, std::forward<Range>(range), std::allocator<typename Container::value_type>());
+};
+
+template <template <class...> class Container, class T, class U>
+constexpr bool test_constraints() {
+  // Input range with the same value type.
+  static_assert(HasFromRangeCtr<Container<T>, InputRange<T>>);
+  // Input range with a convertible value type.
+  static_assert(HasFromRangeCtr<Container<T>, InputRange<U>>);
+  // Input range with a non-convertible value type.
+  static_assert(!HasFromRangeCtr<Container<T>, InputRange<Empty>>);
+  // Not an input range.
+  static_assert(!HasFromRangeCtr<Container<T>, InputRangeNotDerivedFrom>);
+  static_assert(!HasFromRangeCtr<Container<T>, InputRangeNotIndirectlyReadable>);
+  static_assert(!HasFromRangeCtr<Container<T>, InputRangeNotInputOrOutputIterator>);
+
+  // Note: there are no constraints on the allocator (it's not a separate template type of the constructor)`.
+
+  return true;
+}
+
+// Note: `std::array` is used to avoid dealing with `vector<bool>`.
+template <template <class ...> class Container,
+          class T,
+          class Iter,
+          class Sent,
+          class Alloc,
+          std::size_t N,
+          class ValidateFunc>
+constexpr void test_sequence_container_with_input(std::array<T, N>&& input, ValidateFunc validate) {
+  auto in = wrap_input<Iter, Sent>(input);
+
+  { // (range)
+    Container<T> c(std::from_range, in);
+
+    if constexpr (HasSize<Container<T>>) {
+      assert(c.size() == static_cast<std::size_t>(std::distance(c.begin(), c.end())));
+    }
+    assert(std::ranges::equal(in, c));
+    validate(c);
+  }
+
+  { // (range, allocator)
+    Alloc alloc;
+    Container<T, Alloc> c(std::from_range, in, alloc);
+
+    assert(c.get_allocator() == alloc);
+    if constexpr (HasSize<Container<T, Alloc>>) {
+      assert(c.size() == static_cast<std::size_t>(std::distance(c.begin(), c.end())));
+    }
+    assert(std::ranges::equal(in, c));
+    validate(c);
+  }
+}
+
+template <template <class ...> class Container,
+          class T,
+          class Iter,
+          class Sent,
+          class Alloc,
+          class ValidateFunc>
+constexpr void test_sequence_container(ValidateFunc validate) {
+  // Normal input.
+  test_sequence_container_with_input<Container, T, Iter, Sent, Alloc>(std::array{0, 5, 12, 7, -1, 8, 26}, validate);
+  // Empty input.
+  test_sequence_container_with_input<Container, T, Iter, Sent, Alloc>(std::array<int, 0>{}, validate);
+  // Single-element input.
+  test_sequence_container_with_input<Container, T, Iter, Sent, Alloc>(std::array{5}, validate);
+}
+
+template <template <class ...> class Container>
+constexpr void test_sequence_container_move_only() {
+  MoveOnly input[5];
+  std::ranges::subrange in(std::move_iterator(input), std::move_iterator(input + 5));
+
+  [[maybe_unused]] Container<MoveOnly> c(std::from_range, in);
+}
+
+template <class Iter,
+          class Sent,
+          class Alloc,
+          class ValidateFunc>
+constexpr void test_vector_bool(ValidateFunc validate) {
+  // Normal input.
+  test_sequence_container_with_input<std::vector, bool, Iter, Sent, Alloc>(
+      std::array{true, false, false, true, false, true, true, true, false, true}, validate);
+  // Empty input.
+  test_sequence_container_with_input<std::vector, bool, Iter, Sent, Alloc>(std::array<bool, 0>{}, validate);
+  // Single-element input.
+  test_sequence_container_with_input<std::vector, bool, Iter, Sent, Alloc>(std::array{true}, validate);
+}
+
+template <template <class ...> class Container>
+void test_exception_safety_throwing_copy() {
+#if !defined(TEST_HAS_NO_EXCEPTIONS)
+  using T = ThrowingCopy<3>;
+  T::reset();
+  T in[5];
+
+  try {
+    Container<T> c(std::from_range, in);
+    assert(false); // The constructor call above should throw.
+
+  } catch (int) {
+    assert(T::created_by_copying == 3);
+    assert(T::destroyed == 2); // No destructor call for the partially-constructed element.
+  }
+#endif
+}
+
+template <template <class ...> class Container, class T>
+void test_exception_safety_throwing_allocator() {
+#if !defined(TEST_HAS_NO_EXCEPTIONS)
+  T in[] = {0, 1};
+
+  try {
+    ThrowingAllocator<T> alloc;
+
+    globalMemCounter.reset();
+    Container<T, ThrowingAllocator<T>> c(std::from_range, in, alloc);
+    assert(false); // The constructor call above should throw.
+
+  } catch (int) {
+    assert(globalMemCounter.new_called == globalMemCounter.delete_called);
+  }
+#endif
+}
+
+#endif // SUPPORT_FROM_RANGE_SEQUENCE_CONTAINERS_H
diff --git a/libcxx/test/std/containers/sequences/insert_range_sequence_containers.h b/libcxx/test/std/containers/sequences/insert_range_sequence_containers.h
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/containers/sequences/insert_range_sequence_containers.h
@@ -0,0 +1,827 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef SUPPORT_INSERT_RANGE_SEQUENCE_CONTAINERS_H
+#define SUPPORT_INSERT_RANGE_SEQUENCE_CONTAINERS_H
+
+#include <algorithm>
+#include <cassert>
+#include <concepts>
+#include <cstddef>
+#include <initializer_list>
+#include <ranges>
+#include <type_traits>
+#include <vector>
+
+#include "../from_range_helpers.h"
+#include "../insert_range_helpers.h"
+#include "MoveOnly.h"
+#include "almost_satisfies_types.h"
+#include "count_new.h"
+#include "min_allocator.h"
+#include "test_allocator.h"
+#include "test_iterators.h"
+#include "test_macros.h"
+#include "type_algorithms.h"
+
+template <class Container, class Range>
+concept HasInsertRange = requires (Container& c, Range&& range) {
+  c.insert_range(c.end(), range);
+};
+
+template <template <class...> class Container, class T, class U>
+constexpr bool test_constraints_insert_range() {
+  // Input range with the same value type.
+  static_assert(HasInsertRange<Container<T>, InputRange<T>>);
+  // Input range with a convertible value type.
+  static_assert(HasInsertRange<Container<T>, InputRange<U>>);
+  // Input range with a non-convertible value type.
+  static_assert(!HasInsertRange<Container<T>, InputRange<Empty>>);
+  // Not an input range.
+  static_assert(!HasInsertRange<Container<T>, InputRangeNotDerivedFrom>);
+  static_assert(!HasInsertRange<Container<T>, InputRangeNotIndirectlyReadable>);
+  static_assert(!HasInsertRange<Container<T>, InputRangeNotInputOrOutputIterator>);
+
+  return true;
+}
+
+template <class Container, class Range>
+concept HasAppendRange = requires (Container& c, Range&& range) {
+  c.append_range(range);
+};
+
+template <template <class...> class Container, class T, class U>
+constexpr bool test_constraints_append_range() {
+  // Input range with the same value type.
+  static_assert(HasAppendRange<Container<T>, InputRange<T>>);
+  // Input range with a convertible value type.
+  static_assert(HasAppendRange<Container<T>, InputRange<U>>);
+  // Input range with a non-convertible value type.
+  static_assert(!HasAppendRange<Container<T>, InputRange<Empty>>);
+  // Not an input range.
+  static_assert(!HasAppendRange<Container<T>, InputRangeNotDerivedFrom>);
+  static_assert(!HasAppendRange<Container<T>, InputRangeNotIndirectlyReadable>);
+  static_assert(!HasAppendRange<Container<T>, InputRangeNotInputOrOutputIterator>);
+
+  return true;
+}
+
+template <class Container, class Range>
+concept HasPrependRange = requires (Container& c, Range&& range) {
+  c.prepend_range(range);
+};
+
+template <template <class...> class Container, class T, class U>
+constexpr bool test_constraints_prepend_range() {
+  // Input range with the same value type.
+  static_assert(HasPrependRange<Container<T>, InputRange<T>>);
+  // Input range with a convertible value type.
+  static_assert(HasPrependRange<Container<T>, InputRange<U>>);
+  // Input range with a non-convertible value type.
+  static_assert(!HasPrependRange<Container<T>, InputRange<Empty>>);
+  // Not an input range.
+  static_assert(!HasPrependRange<Container<T>, InputRangeNotDerivedFrom>);
+  static_assert(!HasPrependRange<Container<T>, InputRangeNotIndirectlyReadable>);
+  static_assert(!HasPrependRange<Container<T>, InputRangeNotInputOrOutputIterator>);
+
+  return true;
+}
+
+template <class Container, class Range>
+concept HasAssignRange = requires (Container& c, Range&& range) {
+  c.assign_range(range);
+};
+
+template <template <class...> class Container, class T, class U>
+constexpr bool test_constraints_assign_range() {
+  // Input range with the same value type.
+  static_assert(HasAssignRange<Container<T>, InputRange<T>>);
+  // Input range with a convertible value type.
+  static_assert(HasAssignRange<Container<T>, InputRange<U>>);
+  // Input range with a non-convertible value type.
+  static_assert(!HasAssignRange<Container<T>, InputRange<Empty>>);
+  // Not an input range.
+  static_assert(!HasAssignRange<Container<T>, InputRangeNotDerivedFrom>);
+  static_assert(!HasAssignRange<Container<T>, InputRangeNotIndirectlyReadable>);
+  static_assert(!HasAssignRange<Container<T>, InputRangeNotInputOrOutputIterator>);
+
+  return true;
+}
+
+// Empty container.
+
+template <class T>
+TestCase<T> constexpr EmptyContainer_EmptyRange {
+  .initial = {}, .index = 0, .input = {}, .expected = {}
+};
+// Note: specializations for `bool` still use `vector<int>` for inputs. This is to avoid dealing with `vector<bool>` and
+// its iterators over proxy types.
+template <> constexpr TestCase<int> EmptyContainer_EmptyRange<bool> {
+  .initial = {}, .index = 0, .input = {}, .expected = {}
+};
+
+template <class T> constexpr TestCase<T> EmptyContainer_OneElementRange;
+template <> constexpr TestCase<int> EmptyContainer_OneElementRange<int> {
+  .initial = {}, .index = 0, .input = {5}, .expected = {5}
+};
+template <> constexpr TestCase<char> EmptyContainer_OneElementRange<char> {
+  .initial = {}, .index = 0, .input = "a", .expected = "a"
+};
+template <> constexpr TestCase<int> EmptyContainer_OneElementRange<bool> {
+  .initial = {}, .index = 0, .input = {true}, .expected = {true}
+};
+
+template <class T> constexpr TestCase<T> EmptyContainer_MidRange;
+template <> constexpr TestCase<int> EmptyContainer_MidRange<int> {
+  .initial = {}, .index = 0, .input = {5, 3, 1, 7, 9}, .expected = {5, 3, 1, 7, 9}
+};
+template <> constexpr TestCase<char> EmptyContainer_MidRange<char> {
+  .initial = {}, .index = 0, .input = "aeiou", .expected = "aeiou"
+};
+template <> constexpr TestCase<int> EmptyContainer_MidRange<bool> {
+  .initial = {}, .index = 0, .input = {1, 1, 0, 1, 1}, .expected = {1, 1, 0, 1, 1}
+};
+
+// One-element container.
+
+template <class T> constexpr TestCase<T> OneElementContainer_Begin_EmptyRange;
+template <> constexpr TestCase<int> OneElementContainer_Begin_EmptyRange<int> {
+  .initial = {3}, .index = 0, .input = {}, .expected = {3}
+};
+template <> constexpr TestCase<char> OneElementContainer_Begin_EmptyRange<char> {
+  .initial = "B", .index = 0, .input = {}, .expected = "B"
+};
+template <> constexpr TestCase<int> OneElementContainer_Begin_EmptyRange<bool> {
+  .initial = {0}, .index = 0, .input = {}, .expected = {0}
+};
+
+template <class T> constexpr TestCase<T> OneElementContainer_End_EmptyRange;
+template <> constexpr TestCase<int> OneElementContainer_End_EmptyRange<int> {
+  .initial = {3}, .index = 1, .input = {}, .expected = {3}
+};
+template <> constexpr TestCase<char> OneElementContainer_End_EmptyRange<char> {
+  .initial = "B", .index = 1, .input = {}, .expected = "B"
+};
+template <> constexpr TestCase<int> OneElementContainer_End_EmptyRange<bool> {
+  .initial = {0}, .index = 1, .input = {}, .expected = {0}
+};
+
+template <class T> constexpr TestCase<T> OneElementContainer_Begin_OneElementRange;
+template <> constexpr TestCase<int> OneElementContainer_Begin_OneElementRange<int> {
+  .initial = {3}, .index = 0, .input = {-5}, .expected = {-5, 3}
+};
+template <> constexpr TestCase<char> OneElementContainer_Begin_OneElementRange<char> {
+  .initial = "B", .index = 0, .input = "a", .expected = "aB"
+};
+template <> constexpr TestCase<int> OneElementContainer_Begin_OneElementRange<bool> {
+  .initial = {0}, .index = 0, .input = {1}, .expected = {1, 0}
+};
+
+template <class T> constexpr TestCase<T> OneElementContainer_End_OneElementRange;
+template <> constexpr TestCase<int> OneElementContainer_End_OneElementRange<int> {
+  .initial = {3}, .index = 1, .input = {-5}, .expected = {3, -5}
+};
+template <> constexpr TestCase<char> OneElementContainer_End_OneElementRange<char> {
+  .initial = "B", .index = 1, .input = "a", .expected = "Ba"
+};
+template <> constexpr TestCase<int> OneElementContainer_End_OneElementRange<bool> {
+  .initial = {0}, .index = 1, .input = {1}, .expected = {0, 1}
+};
+
+template <class T> constexpr TestCase<T> OneElementContainer_Begin_MidRange;
+template <> constexpr TestCase<int> OneElementContainer_Begin_MidRange<int> {
+  .initial = {3}, .index = 0, .input = {-5, -3, -1, -7, -9}, .expected = {-5, -3, -1, -7, -9, 3}
+};
+template <> constexpr TestCase<char> OneElementContainer_Begin_MidRange<char> {
+  .initial = "B", .index = 0, .input = "aeiou", .expected = "aeiouB"
+};
+template <> constexpr TestCase<int> OneElementContainer_Begin_MidRange<bool> {
+  .initial = {0}, .index = 0, .input = {1, 1, 0, 1, 1}, .expected = {1, 1, 0, 1, 1, 0}
+};
+
+template <class T> constexpr TestCase<T> OneElementContainer_End_MidRange;
+template <> constexpr TestCase<int> OneElementContainer_End_MidRange<int> {
+  .initial = {3}, .index = 1, .input = {-5, -3, -1, -7, -9}, .expected = {3, -5, -3, -1, -7, -9}
+};
+template <> constexpr TestCase<char> OneElementContainer_End_MidRange<char> {
+  .initial = "B", .index = 1, .input = "aeiou", .expected = "Baeiou"
+};
+template <> constexpr TestCase<int> OneElementContainer_End_MidRange<bool> {
+  .initial = {0}, .index = 1, .input = {1, 1, 0, 1, 1}, .expected = {0, 1, 1, 0, 1, 1}
+};
+
+// Full container / empty range.
+
+template <class T> constexpr TestCase<T> FullContainer_Begin_EmptyRange;
+template <> constexpr TestCase<int> FullContainer_Begin_EmptyRange<int> {
+  .initial = {11, 29, 35, 14, 84}, .index = 0, .input = {}, .expected = {11, 29, 35, 14, 84}
+};
+template <> constexpr TestCase<char> FullContainer_Begin_EmptyRange<char> {
+  .initial = "_BCD_", .index = 0, .input = {}, .expected = "_BCD_"
+};
+template <> constexpr TestCase<int> FullContainer_Begin_EmptyRange<bool> {
+  .initial = {0, 0, 1, 0, 0}, .index = 0, .input = {}, .expected = {0, 0, 1, 0, 0}
+};
+
+template <class T> constexpr TestCase<T> FullContainer_Mid_EmptyRange;
+template <> constexpr TestCase<int> FullContainer_Mid_EmptyRange<int> {
+  .initial = {11, 29, 35, 14, 84}, .index = 2, .input = {}, .expected = {11, 29, 35, 14, 84}
+};
+template <> constexpr TestCase<char> FullContainer_Mid_EmptyRange<char> {
+  .initial = "_BCD_", .index = 2, .input = {}, .expected = "_BCD_"
+};
+template <> constexpr TestCase<int> FullContainer_Mid_EmptyRange<bool> {
+  .initial = {0, 0, 1, 0, 0}, .index = 2, .input = {}, .expected = {0, 0, 1, 0, 0}
+};
+
+template <class T> constexpr TestCase<T> FullContainer_End_EmptyRange;
+template <> constexpr TestCase<int> FullContainer_End_EmptyRange<int> {
+  .initial = {11, 29, 35, 14, 84}, .index = 5, .input = {}, .expected = {11, 29, 35, 14, 84}
+};
+template <> constexpr TestCase<char> FullContainer_End_EmptyRange<char> {
+  .initial = "_BCD_", .index = 5, .input = {}, .expected = "_BCD_"
+};
+template <> constexpr TestCase<int> FullContainer_End_EmptyRange<bool> {
+  .initial = {0, 0, 1, 0, 0}, .index = 5, .input = {}, .expected = {0, 0, 1, 0, 0}
+};
+
+// Full container / one-element range.
+
+template <class T> constexpr TestCase<T> FullContainer_Begin_OneElementRange;
+template <> constexpr TestCase<int> FullContainer_Begin_OneElementRange<int> {
+  .initial = {11, 29, 35, 14, 84}, .index = 0, .input = {-5}, .expected = {-5, 11, 29, 35, 14, 84}
+};
+template <> constexpr TestCase<char> FullContainer_Begin_OneElementRange<char> {
+  .initial = "_BCD_", .index = 0, .input = "a", .expected = "a_BCD_"
+};
+template <> constexpr TestCase<int> FullContainer_Begin_OneElementRange<bool> {
+  .initial = {0, 0, 1, 0, 0}, .index = 0, .input = {1}, .expected = {1, 0, 0, 1, 0, 0}
+};
+
+template <class T> constexpr TestCase<T> FullContainer_Mid_OneElementRange;
+template <> constexpr TestCase<int> FullContainer_Mid_OneElementRange<int> {
+  .initial = {11, 29, 35, 14, 84}, .index = 2, .input = {-5}, .expected = {11, 29, -5, 35, 14, 84}
+};
+template <> constexpr TestCase<char> FullContainer_Mid_OneElementRange<char> {
+  .initial = "_BCD_", .index = 2, .input = "a", .expected = "_BaCD_"
+};
+template <> constexpr TestCase<int> FullContainer_Mid_OneElementRange<bool> {
+  .initial = {0, 0, 1, 0, 0}, .index = 2, .input = {1}, .expected = {0, 0, 1, 1, 0, 0}
+};
+
+template <class T> constexpr TestCase<T> FullContainer_End_OneElementRange;
+template <> constexpr TestCase<int> FullContainer_End_OneElementRange<int> {
+  .initial = {11, 29, 35, 14, 84}, .index = 5, .input = {-5}, .expected = {11, 29, 35, 14, 84, -5}
+};
+template <> constexpr TestCase<char> FullContainer_End_OneElementRange<char> {
+  .initial = "_BCD_", .index = 5, .input = "a", .expected = "_BCD_a"
+};
+template <> constexpr TestCase<int> FullContainer_End_OneElementRange<bool> {
+  .initial = {0, 0, 1, 0, 0}, .index = 5, .input = {1}, .expected = {0, 0, 1, 0, 0, 1}
+};
+
+// Full container / mid-sized range.
+
+template <class T> constexpr TestCase<T> FullContainer_Begin_MidRange;
+template <> constexpr TestCase<int> FullContainer_Begin_MidRange<int> {
+  .initial = {11, 29, 35, 14, 84},
+  .index = 0,
+  .input = {-5, -3, -1, -7, -9},
+  .expected = {-5, -3, -1, -7, -9, 11, 29, 35, 14, 84}
+};
+template <> constexpr TestCase<char> FullContainer_Begin_MidRange<char> {
+  .initial = "_BCD_",
+  .index = 0,
+  .input = "aeiou",
+  .expected = "aeiou_BCD_"
+};
+template <> constexpr TestCase<int> FullContainer_Begin_MidRange<bool> {
+  .initial = {0, 0, 1, 0, 1},
+  .index = 0,
+  .input = {1, 1, 0, 1, 1},
+  .expected = {1, 1, 0, 1, 1, 0, 0, 1, 0, 1}
+};
+
+template <class T> constexpr TestCase<T> FullContainer_Mid_MidRange;
+template <> constexpr TestCase<int> FullContainer_Mid_MidRange<int> {
+  .initial = {11, 29, 35, 14, 84},
+  .index = 2,
+  .input = {-5, -3, -1, -7, -9},
+  .expected = {11, 29, -5, -3, -1, -7, -9, 35, 14, 84}
+};
+template <> constexpr TestCase<char> FullContainer_Mid_MidRange<char> {
+  .initial = "_BCD_",
+  .index = 2,
+  .input = "aeiou",
+  .expected = "_BaeiouCD_"
+};
+template <> constexpr TestCase<int> FullContainer_Mid_MidRange<bool> {
+  .initial = {0, 0, 1, 0, 1},
+  .index = 2,
+  .input = {1, 1, 0, 1, 1},
+  .expected = {0, 0, 1, 1, 0, 1, 1, 1, 0, 1}
+};
+
+template <class T> constexpr TestCase<T> FullContainer_End_MidRange;
+template <> constexpr TestCase<int> FullContainer_End_MidRange<int> {
+  .initial = {11, 29, 35, 14, 84},
+  .index = 5,
+  .input = {-5, -3, -1, -7, -9},
+  .expected = {11, 29, 35, 14, 84, -5, -3, -1, -7, -9}
+};
+template <> constexpr TestCase<char> FullContainer_End_MidRange<char> {
+  .initial = "_BCD_",
+  .index = 5,
+  .input = "aeiou",
+  .expected = "_BCD_aeiou"
+};
+template <> constexpr TestCase<int> FullContainer_End_MidRange<bool> {
+  .initial = {0, 0, 1, 0, 1},
+  .index = 5,
+  .input = {1, 1, 0, 1, 1},
+  .expected = {0, 0, 1, 0, 1, 1, 1, 0, 1, 1}
+};
+
+// Full container / long range.
+
+template <class T> constexpr TestCase<T> FullContainer_Begin_LongRange;
+template <> constexpr TestCase<int> FullContainer_Begin_LongRange<int> {
+  .initial = {11, 29, 35, 14, 84},
+  .index = 0,
+  .input = {-5, -3, -1, -7, -9, -19, -48, -56, -13, -14, -29, -88, -17, -1, -5, -11, -89, -21, -33, -48},
+  .expected = {
+      -5, -3, -1, -7, -9, -19, -48, -56, -13, -14, -29, -88, -17, -1, -5, -11, -89, -21, -33, -48, 11, 29, 35, 14, 84
+  }
+};
+template <> constexpr TestCase<char> FullContainer_Begin_LongRange<char> {
+  .initial = "_BCD_",
+  .index = 0,
+  .input = "aeiouqwxyz5781964203",
+  .expected = "aeiouqwxyz5781964203_BCD_"
+};
+template <> constexpr TestCase<int> FullContainer_Begin_LongRange<bool> {
+  .initial = {0, 0, 1, 0, 0},
+  .index = 0,
+  .input = {1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0},
+  .expected = {
+      1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0
+  }
+};
+
+template <class T> constexpr TestCase<T> FullContainer_Mid_LongRange;
+template <> constexpr TestCase<int> FullContainer_Mid_LongRange<int> {
+  .initial = {11, 29, 35, 14, 84},
+  .index = 2,
+  .input = {-5, -3, -1, -7, -9, -19, -48, -56, -13, -14, -29, -88, -17, -1, -5, -11, -89, -21, -33, -48},
+  .expected = {
+      11, 29, -5, -3, -1, -7, -9, -19, -48, -56, -13, -14, -29, -88, -17, -1, -5, -11, -89, -21, -33, -48, 35, 14, 84
+  }
+};
+template <> constexpr TestCase<char> FullContainer_Mid_LongRange<char> {
+  .initial = "_BCD_",
+  .index = 2,
+  .input = "aeiouqwxyz5781964203",
+  .expected = "_Baeiouqwxyz5781964203CD_"
+};
+template <> constexpr TestCase<int> FullContainer_Mid_LongRange<bool> {
+  .initial = {0, 0, 1, 0, 0},
+  .index = 2,
+  .input = {1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0},
+  .expected = {
+      0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 1, 0, 0
+  }
+};
+
+template <class T> constexpr TestCase<T> FullContainer_End_LongRange;
+template <> constexpr TestCase<int> FullContainer_End_LongRange<int> {
+  .initial = {11, 29, 35, 14, 84},
+  .index = 5,
+  .input = {-5, -3, -1, -7, -9, -19, -48, -56, -13, -14, -29, -88, -17, -1, -5, -11, -89, -21, -33, -48},
+  .expected = {
+      11, 29, 35, 14, 84, -5, -3, -1, -7, -9, -19, -48, -56, -13, -14, -29, -88, -17, -1, -5, -11, -89, -21, -33, -48
+  }
+};
+template <> constexpr TestCase<char> FullContainer_End_LongRange<char> {
+  .initial = "_BCD_",
+  .index = 5,
+  .input = "aeiouqwxyz5781964203",
+  .expected = "_BCD_aeiouqwxyz5781964203"
+};
+template <> constexpr TestCase<int> FullContainer_End_LongRange<bool> {
+  .initial = {0, 0, 1, 0, 1},
+  .index = 5,
+  .input = {1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0},
+  .expected = {
+      0, 0, 1, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0
+  }
+};
+
+// Sequence containers tests.
+
+template <class Container, class Iter, class Sent, class Validate>
+constexpr void test_sequence_insert_range(Validate validate) {
+  using T = typename Container::value_type;
+  auto get_pos = [](auto& c, auto& test_case) { return std::ranges::next(c.begin(), test_case.index); };
+
+  auto test = [&](auto& test_case) {
+    Container c(test_case.initial.begin(), test_case.initial.end());
+    auto in = wrap_input<Iter, Sent>(test_case.input);
+    auto pos = get_pos(c, test_case);
+
+    auto result = c.insert_range(pos, in);
+    assert(result == get_pos(c, test_case));
+    validate(c);
+    return std::ranges::equal(c, test_case.expected);
+  };
+
+  { // Empty container.
+    // empty_c.insert_range(end, empty_range)
+    assert(test(EmptyContainer_EmptyRange<T>));
+    // empty_c.insert_range(end, one_element_range)
+    assert(test(EmptyContainer_OneElementRange<T>));
+    // empty_c.insert_range(end, mid_range)
+    assert(test(EmptyContainer_MidRange<T>));
+  }
+
+  { // One-element container.
+    // one_element_c.insert_range(begin, empty_range)
+    assert(test(OneElementContainer_Begin_EmptyRange<T>));
+    // one_element_c.insert_range(end, empty_range)
+    assert(test(OneElementContainer_End_EmptyRange<T>));
+    // one_element_c.insert_range(begin, one_element_range)
+    assert(test(OneElementContainer_Begin_OneElementRange<T>));
+    // one_element_c.insert_range(end, one_element_range)
+    assert(test(OneElementContainer_End_OneElementRange<T>));
+    // one_element_c.insert_range(begin, mid_range)
+    assert(test(OneElementContainer_Begin_MidRange<T>));
+    // one_element_c.insert_range(end, mid_range)
+    assert(test(OneElementContainer_End_MidRange<T>));
+  }
+
+  { // Full container.
+    // full_container.insert_range(begin, empty_range)
+    assert(test(FullContainer_Begin_EmptyRange<T>));
+    // full_container.insert_range(mid, empty_range)
+    assert(test(FullContainer_Mid_EmptyRange<T>));
+    // full_container.insert_range(end, empty_range)
+    assert(test(FullContainer_End_EmptyRange<T>));
+    // full_container.insert_range(begin, one_element_range)
+    assert(test(FullContainer_Begin_OneElementRange<T>));
+    // full_container.insert_range(end, one_element_range)
+    assert(test(FullContainer_Mid_OneElementRange<T>));
+    // full_container.insert_range(end, one_element_range)
+    assert(test(FullContainer_End_OneElementRange<T>));
+    // full_container.insert_range(begin, mid_range)
+    assert(test(FullContainer_Begin_MidRange<T>));
+    // full_container.insert_range(mid, mid_range)
+    assert(test(FullContainer_Mid_MidRange<T>));
+    // full_container.insert_range(end, mid_range)
+    assert(test(FullContainer_End_MidRange<T>));
+    // full_container.insert_range(begin, long_range)
+    assert(test(FullContainer_Begin_LongRange<T>));
+    // full_container.insert_range(mid, long_range)
+    assert(test(FullContainer_Mid_LongRange<T>));
+    // full_container.insert_range(end, long_range)
+    assert(test(FullContainer_End_LongRange<T>));
+  }
+}
+
+template <class Container, class Iter, class Sent, class Validate>
+constexpr void test_sequence_prepend_range(Validate validate) {
+  using T = typename Container::value_type;
+
+  auto test = [&](auto& test_case) {
+    Container c(test_case.initial.begin(), test_case.initial.end());
+    auto in = wrap_input<Iter, Sent>(test_case.input);
+
+    c.prepend_range(in);
+    validate(c);
+    return std::ranges::equal(c, test_case.expected);
+  };
+
+  { // Empty container.
+    // empty_c.prepend_range(empty_range)
+    assert(test(EmptyContainer_EmptyRange<T>));
+    // empty_c.prepend_range(one_element_range)
+    assert(test(EmptyContainer_OneElementRange<T>));
+    // empty_c.prepend_range(mid_range)
+    assert(test(EmptyContainer_MidRange<T>));
+  }
+
+  { // One-element container.
+    // one_element_c.prepend_range(empty_range)
+    assert(test(OneElementContainer_Begin_EmptyRange<T>));
+    // one_element_c.prepend_range(one_element_range)
+    assert(test(OneElementContainer_Begin_OneElementRange<T>));
+    // one_element_c.prepend_range(mid_range)
+    assert(test(OneElementContainer_Begin_MidRange<T>));
+  }
+
+  { // Full container.
+    // full_container.prepend_range(empty_range)
+    assert(test(FullContainer_Begin_EmptyRange<T>));
+    // full_container.prepend_range(one_element_range)
+    assert(test(FullContainer_Begin_OneElementRange<T>));
+    // full_container.prepend_range(mid_range)
+    assert(test(FullContainer_Begin_MidRange<T>));
+    // full_container.prepend_range(long_range)
+    assert(test(FullContainer_Begin_LongRange<T>));
+  }
+}
+
+template <class Container, class Iter, class Sent, class Validate>
+constexpr void test_sequence_append_range(Validate validate) {
+  using T = typename Container::value_type;
+
+  auto test = [&](auto& test_case) {
+    Container c(test_case.initial.begin(), test_case.initial.end());
+    auto in = wrap_input<Iter, Sent>(test_case.input);
+
+    c.append_range(in);
+    validate(c);
+    return std::ranges::equal(c, test_case.expected);
+  };
+
+  { // Empty container.
+    // empty_c.append_range(empty_range)
+    assert(test(EmptyContainer_EmptyRange<T>));
+    // empty_c.append_range(one_element_range)
+    assert(test(EmptyContainer_OneElementRange<T>));
+    // empty_c.append_range(mid_range)
+    assert(test(EmptyContainer_MidRange<T>));
+  }
+
+  { // One-element container.
+    // one_element_c.append_range(empty_range)
+    assert(test(OneElementContainer_End_EmptyRange<T>));
+    // one_element_c.append_range(one_element_range)
+    assert(test(OneElementContainer_End_OneElementRange<T>));
+    // one_element_c.append_range(mid_range)
+    assert(test(OneElementContainer_End_MidRange<T>));
+  }
+
+  { // Full container.
+    // full_container.append_range(empty_range)
+    assert(test(FullContainer_End_EmptyRange<T>));
+    // full_container.append_range(one_element_range)
+    assert(test(FullContainer_End_OneElementRange<T>));
+    // full_container.append_range(mid_range)
+    assert(test(FullContainer_End_MidRange<T>));
+    // full_container.append_range(long_range)
+    assert(test(FullContainer_End_LongRange<T>));
+  }
+}
+
+template <class Container, class Iter, class Sent, class Validate>
+constexpr void test_sequence_assign_range(Validate validate) {
+  using T = typename Container::value_type;
+
+  auto& initial_empty = EmptyContainer_EmptyRange<T>.initial;
+  auto& initial_one_element = OneElementContainer_Begin_EmptyRange<T>.initial;
+  auto& initial_full = FullContainer_Begin_EmptyRange<T>.initial;
+  auto& input_empty = FullContainer_Begin_EmptyRange<T>.input;
+  auto& input_one_element = FullContainer_Begin_OneElementRange<T>.input;
+  auto& input_mid_range = FullContainer_Begin_MidRange<T>.input;
+  auto& input_long_range = FullContainer_Begin_LongRange<T>.input;
+
+  auto test = [&](auto& initial, auto& input) {
+    Container c(initial.begin(), initial.end());
+    auto in = wrap_input<Iter, Sent>(input);
+
+    c.assign_range(in);
+    validate(c);
+    return std::ranges::equal(c, input);
+  };
+
+  { // Empty container.
+    // empty_container.assign_range(empty_range)
+    assert(test(initial_empty, input_empty));
+    // empty_container.assign_range(one_element_range)
+    assert(test(initial_empty, input_one_element));
+    // empty_container.assign_range(mid_range)
+    assert(test(initial_empty, input_mid_range));
+    // empty_container.assign_range(long_range)
+    assert(test(initial_empty, input_long_range));
+  }
+
+  { // One-element container.
+    // one_element_container.assign_range(empty_range)
+    assert(test(initial_one_element, input_empty));
+    // one_element_container.assign_range(one_element_range)
+    assert(test(initial_one_element, input_one_element));
+    // one_element_container.assign_range(mid_range)
+    assert(test(initial_one_element, input_mid_range));
+    // one_element_container.assign_range(long_range)
+    assert(test(initial_one_element, input_long_range));
+  }
+
+  { // Full container.
+    // full_container.assign_range(empty_range)
+    assert(test(initial_full, input_empty));
+    // full_container.assign_range(one_element_range)
+    assert(test(initial_full, input_one_element));
+    // full_container.assign_range(mid_range)
+    assert(test(initial_full, input_mid_range));
+    // full_container.assign_range(long_range)
+    assert(test(initial_full, input_long_range));
+  }
+}
+
+// Move-only types.
+
+template <template <class ...> class Container>
+constexpr void test_sequence_insert_range_move_only() {
+  MoveOnly input[5];
+  std::ranges::subrange in(std::move_iterator(input), std::move_iterator(input + 5));
+
+  Container<MoveOnly> c;
+  c.insert_range(c.end(), in);
+}
+
+template <template <class ...> class Container>
+constexpr void test_sequence_prepend_range_move_only() {
+  MoveOnly input[5];
+  std::ranges::subrange in(std::move_iterator(input), std::move_iterator(input + 5));
+
+  Container<MoveOnly> c;
+  c.prepend_range(in);
+}
+
+template <template <class ...> class Container>
+constexpr void test_sequence_append_range_move_only() {
+  MoveOnly input[5];
+  std::ranges::subrange in(std::move_iterator(input), std::move_iterator(input + 5));
+
+  Container<MoveOnly> c;
+  c.append_range(in);
+}
+
+template <template <class ...> class Container>
+constexpr void test_sequence_assign_range_move_only() {
+  MoveOnly input[5];
+  std::ranges::subrange in(std::move_iterator(input), std::move_iterator(input + 5));
+
+  Container<MoveOnly> c;
+  c.assign_range(in);
+}
+
+// Exception safety.
+
+template <template <class ...> class Container>
+void test_insert_range_exception_safety_throwing_copy() {
+#if !defined(TEST_HAS_NO_EXCEPTIONS)
+  using T = ThrowingCopy<3>;
+  T::reset();
+  T in[5];
+
+  try {
+    Container<T> c;
+    c.insert_range(c.end(), in);
+    assert(false); // The function call above should throw.
+
+  } catch (int) {
+    assert(T::created_by_copying == 3);
+    assert(T::destroyed == 2); // No destructor call for the partially-constructed element.
+  }
+#endif
+}
+
+template <template <class ...> class Container, class T>
+void test_insert_range_exception_safety_throwing_allocator() {
+#if !defined(TEST_HAS_NO_EXCEPTIONS)
+  T in[] = {0, 1};
+
+  try {
+    ThrowingAllocator<T> alloc;
+
+    globalMemCounter.reset();
+    Container<T, ThrowingAllocator<T>> c(alloc);
+    c.insert_range(c.end(), in);
+    assert(false); // The function call above should throw.
+
+  } catch (int) {
+    assert(globalMemCounter.new_called == globalMemCounter.delete_called);
+  }
+#endif
+}
+
+template <template <class ...> class Container>
+void test_prepend_range_exception_safety_throwing_copy() {
+#if !defined(TEST_HAS_NO_EXCEPTIONS)
+  using T = ThrowingCopy<3>;
+  T::reset();
+  T in[5];
+
+  try {
+    Container<T> c;
+    c.prepend_range(in);
+    assert(false); // The function call above should throw.
+
+  } catch (int) {
+    assert(T::created_by_copying == 3);
+    assert(T::destroyed == 2); // No destructor call for the partially-constructed element.
+  }
+#endif
+}
+
+template <template <class ...> class Container, class T>
+void test_prepend_range_exception_safety_throwing_allocator() {
+#if !defined(TEST_HAS_NO_EXCEPTIONS)
+  T in[] = {0, 1};
+
+  try {
+    ThrowingAllocator<T> alloc;
+
+    globalMemCounter.reset();
+    Container<T, ThrowingAllocator<T>> c(alloc);
+    c.prepend_range(in);
+    assert(false); // The function call above should throw.
+
+  } catch (int) {
+    assert(globalMemCounter.new_called == globalMemCounter.delete_called);
+  }
+#endif
+}
+
+template <template <class ...> class Container>
+void test_append_range_exception_safety_throwing_copy() {
+#if !defined(TEST_HAS_NO_EXCEPTIONS)
+  using T = ThrowingCopy<3>;
+  T::reset();
+  T in[5];
+
+  try {
+    Container<T> c;
+    c.append_range(in);
+    assert(false); // The function call above should throw.
+
+  } catch (int) {
+    assert(T::created_by_copying == 3);
+    assert(T::destroyed == 2); // No destructor call for the partially-constructed element.
+  }
+#endif
+}
+
+template <template <class ...> class Container, class T>
+void test_append_range_exception_safety_throwing_allocator() {
+#if !defined(TEST_HAS_NO_EXCEPTIONS)
+  T in[] = {0, 1};
+
+  try {
+    ThrowingAllocator<T> alloc;
+
+    globalMemCounter.reset();
+    Container<T, ThrowingAllocator<T>> c(alloc);
+    c.append_range(in);
+    assert(false); // The function call above should throw.
+
+  } catch (int) {
+    assert(globalMemCounter.new_called == globalMemCounter.delete_called);
+  }
+#endif
+}
+
+template <template <class ...> class Container>
+void test_assign_range_exception_safety_throwing_copy() {
+#if !defined(TEST_HAS_NO_EXCEPTIONS)
+  using T = ThrowingCopy<3>;
+  T::reset();
+  T in[5];
+
+  try {
+    Container<T> c;
+    c.assign_range(in);
+    assert(false); // The function call above should throw.
+
+  } catch (int) {
+    assert(T::created_by_copying == 3);
+    assert(T::destroyed == 2); // No destructor call for the partially-constructed element.
+  }
+#endif
+}
+
+template <template <class ...> class Container, class T>
+void test_assign_range_exception_safety_throwing_allocator() {
+#if !defined(TEST_HAS_NO_EXCEPTIONS)
+  T in[] = {0, 1};
+
+  try {
+    ThrowingAllocator<T> alloc;
+
+    globalMemCounter.reset();
+    Container<T, ThrowingAllocator<T>> c(alloc);
+    c.assign_range(in);
+    assert(false); // The function call above should throw.
+
+  } catch (int) {
+    assert(globalMemCounter.new_called == globalMemCounter.delete_called);
+  }
+#endif
+}
+
+#endif // SUPPORT_INSERT_RANGE_SEQUENCE_CONTAINERS_H
diff --git a/libcxx/test/std/strings/basic.string/string.cons/from_range.pass.cpp b/libcxx/test/std/strings/basic.string/string.cons/from_range.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/strings/basic.string/string.cons/from_range.pass.cpp
@@ -0,0 +1,131 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+#include <algorithm>
+#include <string>
+#include <utility>
+#include <vector>
+
+#include "../../../containers/from_range_helpers.h"
+#include "../../../containers/sequences/from_range_sequence_containers.h"
+#include "test_macros.h"
+
+// template<container-compatible-range<T> R>
+//   basic_string(from_range_t, R&& rg, const Allocator& = Allocator()); // C++23
+
+std::vector<char> long_string = {
+  'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w',
+  'x', 'y', 'z', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9'
+};
+
+template <class Container, class Range, class Alloc>
+concept StringHasFromRangeAllocCtr = requires (Range&& range, const Alloc& alloc) {
+  Container(std::from_range, std::forward<Range>(range), alloc);
+};
+
+constexpr bool test_constraints() {
+  // (from_range, range)
+  //
+  // Input range with the same value type.
+  static_assert(HasFromRangeCtr<std::string, InputRange<char>>);
+  // Input range with a convertible value type.
+  static_assert(HasFromRangeCtr<std::string, InputRange<int>>);
+  // Input range with a non-convertible value type.
+  static_assert(!HasFromRangeCtr<std::string, InputRange<Empty>>);
+  // Not an input range.
+  static_assert(!HasFromRangeCtr<std::string, InputRangeNotDerivedFrom>);
+  static_assert(!HasFromRangeCtr<std::string, InputRangeNotIndirectlyReadable>);
+  static_assert(!HasFromRangeCtr<std::string, InputRangeNotInputOrOutputIterator>);
+
+  // (from_range, range, alloc)
+  //
+  // Input range with the same value type.
+  using Alloc = test_allocator<char>;
+  using StringWithAlloc = std::basic_string<char, std::char_traits<char>, Alloc>;
+  static_assert(StringHasFromRangeAllocCtr<StringWithAlloc, InputRange<char>, Alloc>);
+  // Input range with a convertible value type.
+  static_assert(StringHasFromRangeAllocCtr<StringWithAlloc, InputRange<int>, Alloc>);
+  // Input range with a non-convertible value type.
+  static_assert(!StringHasFromRangeAllocCtr<StringWithAlloc, InputRange<Empty>, Alloc>);
+  // Not an input range.
+  static_assert(!StringHasFromRangeAllocCtr<StringWithAlloc, InputRangeNotDerivedFrom, Alloc>);
+  static_assert(!StringHasFromRangeAllocCtr<StringWithAlloc, InputRangeNotIndirectlyReadable, Alloc>);
+  static_assert(!StringHasFromRangeAllocCtr<StringWithAlloc, InputRangeNotInputOrOutputIterator, Alloc>);
+  // Not an allocator.
+  static_assert(!StringHasFromRangeAllocCtr<StringWithAlloc, InputRange<char>, Empty>);
+
+  return true;
+}
+
+template <class Iter,
+          class Sent,
+          class Alloc>
+constexpr void test_with_input(std::vector<char> input) {
+  auto b = Iter(input.data());
+  auto e = Iter(input.data() + input.size());
+  std::ranges::subrange in(std::move(b), Sent(std::move(e)));
+
+  { // (range)
+    std::string c(std::from_range, in);
+
+    LIBCPP_ASSERT(c.__invariants());
+    assert(c.size() == static_cast<std::size_t>(std::distance(c.begin(), c.end())));
+    assert(std::ranges::equal(in, c));
+  }
+
+  { // (range, allocator)
+    Alloc alloc;
+    std::basic_string<char, std::char_traits<char>, Alloc> c(std::from_range, in, alloc);
+
+    LIBCPP_ASSERT(c.__invariants());
+    assert(c.get_allocator() == alloc);
+    assert(c.size() == static_cast<std::size_t>(std::distance(c.begin(), c.end())));
+    assert(std::ranges::equal(in, c));
+  }
+}
+
+void test_string_exception_safety_throwing_allocator() {
+#if !defined(TEST_HAS_NO_EXCEPTIONS)
+  try {
+    ThrowingAllocator<char> alloc;
+
+    globalMemCounter.reset();
+    // Note: the input string must be long enough to prevent SSO, otherwise the allocator won't be used.
+    std::basic_string<char, std::char_traits<char>, ThrowingAllocator<char>> c(std::from_range, long_string, alloc);
+    assert(false); // The constructor call should throw.
+
+  } catch (int) {
+    assert(globalMemCounter.new_called == globalMemCounter.delete_called);
+  }
+#endif
+}
+
+int main(int, char**) {
+  for_all_iterators_and_allocators<char>([]<class Iter, class Sent, class Alloc>() {
+    // Shorter input -- SSO.
+    test_with_input<Iter, Sent, Alloc>({'a', 'b', 'c', 'd', 'e'});
+
+    // Longer input -- no SSO.
+    test_with_input<Iter, Sent, Alloc>(long_string);
+
+    // Empty input.
+    test_with_input<Iter, Sent, Alloc>({});
+
+    // Single-element input.
+    test_with_input<Iter, Sent, Alloc>({'a'});
+  });
+
+  static_assert(test_constraints());
+
+  // Note: `test_exception_safety_throwing_copy` doesn't apply because copying a `char` cannot throw.
+  test_string_exception_safety_throwing_allocator();
+
+  return 0;
+}
diff --git a/libcxx/test/std/strings/basic.string/string.cons/from_range_deduction.pass.cpp b/libcxx/test/std/strings/basic.string/string.cons/from_range_deduction.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/strings/basic.string/string.cons/from_range_deduction.pass.cpp
@@ -0,0 +1,48 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// <string>
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+// template<ranges::input_range R,
+//          class Allocator = allocator<ranges::range_value_t<R>>>
+//   basic_string(from_range_t, R&&, Allocator = Allocator())
+//     -> basic_string<ranges::range_value_t<R>, char_traits<ranges::range_value_t<R>>,
+//                     Allocator>; // C++23
+//
+// The deduction guide shall not participate in overload resolution if Allocator
+// is a type that does not qualify as an allocator (in addition to the `input_range` concept being satisfied by `R`).
+
+#include <array>
+#include <string>
+
+#include "deduction_guides_sfinae_checks.h"
+#include "test_allocator.h"
+
+int main(int, char**) {
+  using Char = char16_t;
+
+  {
+    std::basic_string c(std::from_range, std::array<Char, 0>());
+    static_assert(std::is_same_v<decltype(c), std::basic_string<Char>>);
+  }
+
+  {
+    using Alloc = test_allocator<Char>;
+    std::basic_string c(std::from_range, std::array<Char, 0>(), Alloc());
+    static_assert(std::is_same_v<decltype(c), std::basic_string<Char, std::char_traits<Char>, Alloc>>);
+  }
+
+  // Note: defining `value_type` is a workaround because one of the deduction guides will end up instantiating
+  // `basic_string`, and that would fail with a hard error if the given allocator doesn't define `value_type`.
+  struct BadAlloc { using value_type = char; };
+  SequenceContainerDeductionGuidesSfinaeAway<std::basic_string, std::basic_string<char>, BadAlloc>();
+
+  return 0;
+}
diff --git a/libcxx/test/std/strings/basic.string/string.cons/iter_alloc_deduction.pass.cpp b/libcxx/test/std/strings/basic.string/string.cons/iter_alloc_deduction.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.cons/iter_alloc_deduction.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.cons/iter_alloc_deduction.pass.cpp
@@ -47,6 +47,7 @@
 static_assert( CanDeduce<char*, std::allocator<char>>::value);
 static_assert(!CanDeduce<NotAnIterator, std::allocator<char>>::value);
 static_assert(!CanDeduce<NotAnInputIterator, std::allocator<char16_t>>::value);
+static_assert(!CanDeduce<char*, NotAnAllocator<char>>::value);
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
 static_assert( CanDeduce<wchar_t*, std::allocator<wchar_t>>::value);
 static_assert(!CanDeduce<wchar_t const*, NotAnAllocator<wchar_t>>::value);
diff --git a/libcxx/test/std/strings/basic.string/string.modifiers/string_append/append_range.pass.cpp b/libcxx/test/std/strings/basic.string/string.modifiers/string_append/append_range.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/strings/basic.string/string.modifiers/string_append/append_range.pass.cpp
@@ -0,0 +1,68 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+// template<container-compatible-range<charT> R>
+//   constexpr basic_string& append_range(R&& rg); // C++23
+
+#include <string>
+
+#include "../../../../containers/sequences/insert_range_sequence_containers.h"
+#include "test_macros.h"
+
+void test_string_append_range_return_value() {
+  std::string c;
+  static_assert(std::is_lvalue_reference_v<decltype(
+      c.append_range(FullContainer_Begin_EmptyRange<char>.input)
+  )>);
+  assert(&c.append_range(FullContainer_Begin_EmptyRange<char>.input) == &c);
+  assert(&c.append_range(FullContainer_Begin_OneElementRange<char>.input) == &c);
+  assert(&c.append_range(FullContainer_Begin_MidRange<char>.input) == &c);
+  assert(&c.append_range(FullContainer_Begin_LongRange<char>.input) == &c);
+}
+
+void test_string_append_range_exception_safety_throwing_allocator() {
+#if !defined(TEST_HAS_NO_EXCEPTIONS)
+  // Note: the input string must be long enough to prevent SSO, otherwise the allocator won't be used.
+  std::string in(64, 'a');
+
+  try {
+    ThrowingAllocator<char> alloc;
+
+    globalMemCounter.reset();
+    std::basic_string<char, std::char_traits<char>, ThrowingAllocator<char>> c(alloc);
+    c.append_range(in);
+    assert(false); // The function call above should throw.
+
+  } catch (int) {
+    assert(globalMemCounter.new_called == globalMemCounter.delete_called);
+  }
+#endif
+}
+
+// Tested cases:
+// - different kinds of insertions (appending an {empty/one-element/mid-sized/long range} into an
+//   {empty/one-element/full} container);
+// - an exception is thrown when allocating new elements.
+int main(int, char**) {
+  static_assert(test_constraints_append_range<std::basic_string, char, int>());
+
+  for_all_iterators_and_allocators<char, const char*>([]<class Iter, class Sent, class Alloc>() {
+    test_sequence_append_range<std::basic_string<char, std::char_traits<char>, Alloc>, Iter, Sent>([](auto&& c) {
+      LIBCPP_ASSERT(c.__invariants());
+    });
+  });
+
+  test_string_append_range_return_value();
+
+  // Note: `test_append_range_exception_safety_throwing_copy` doesn't apply because copying chars cannot throw.
+  test_string_append_range_exception_safety_throwing_allocator();
+
+  return 0;
+}
diff --git a/libcxx/test/std/strings/basic.string/string.modifiers/string_assign/assign_range.pass.cpp b/libcxx/test/std/strings/basic.string/string.modifiers/string_assign/assign_range.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/strings/basic.string/string.modifiers/string_assign/assign_range.pass.cpp
@@ -0,0 +1,68 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+// template<container-compatible-range<charT> R>
+//   constexpr basic_string& assign_range(R&& rg); // C++23
+
+#include <string>
+
+#include "../../../../containers/sequences/insert_range_sequence_containers.h"
+#include "test_macros.h"
+
+void test_string_assign_range_return_value() {
+  std::string c;
+  static_assert(std::is_lvalue_reference_v<decltype(
+      c.assign_range(FullContainer_Begin_EmptyRange<char>.input)
+  )>);
+  assert(&c.assign_range(FullContainer_Begin_EmptyRange<char>.input) == &c);
+  assert(&c.assign_range(FullContainer_Begin_OneElementRange<char>.input) == &c);
+  assert(&c.assign_range(FullContainer_Begin_MidRange<char>.input) == &c);
+  assert(&c.assign_range(FullContainer_Begin_LongRange<char>.input) == &c);
+}
+
+void test_string_assign_range_exception_safety_throwing_allocator() {
+#if !defined(TEST_HAS_NO_EXCEPTIONS)
+  // Note: the input string must be long enough to prevent SSO, otherwise the allocator won't be used.
+  std::string in(64, 'a');
+
+  try {
+    ThrowingAllocator<char> alloc;
+
+    globalMemCounter.reset();
+    std::basic_string<char, std::char_traits<char>, ThrowingAllocator<char>> c(alloc);
+    c.assign_range(in);
+    assert(false); // The function call above should throw.
+
+  } catch (int) {
+    assert(globalMemCounter.new_called == globalMemCounter.delete_called);
+  }
+#endif
+}
+
+// Tested cases:
+// - different kinds of assignments (assigning an {empty/one-element/mid-sized/long range} to an
+//   {empty/one-element/full} container);
+// - an exception is thrown when allocating new elements.
+int main(int, char**) {
+  static_assert(test_constraints_assign_range<std::basic_string, char, int>());
+
+  for_all_iterators_and_allocators<char, const char*>([]<class Iter, class Sent, class Alloc>() {
+    test_sequence_assign_range<std::basic_string<char, std::char_traits<char>, Alloc>, Iter, Sent>([](auto&& c) {
+      LIBCPP_ASSERT(c.__invariants());
+    });
+  });
+
+  test_string_assign_range_return_value();
+
+  // Note: `test_assign_range_exception_safety_throwing_copy` doesn't apply because copying chars cannot throw.
+  test_string_assign_range_exception_safety_throwing_allocator();
+
+  return 0;
+}
diff --git a/libcxx/test/std/strings/basic.string/string.modifiers/string_insert/insert_range.pass.cpp b/libcxx/test/std/strings/basic.string/string.modifiers/string_insert/insert_range.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/strings/basic.string/string.modifiers/string_insert/insert_range.pass.cpp
@@ -0,0 +1,55 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+// template<container-compatible-range<charT> R>
+//   constexpr iterator insert_range(const_iterator p, R&& rg);                                // C++23
+
+#include <string>
+
+#include "../../../../containers/sequences/insert_range_sequence_containers.h"
+#include "test_macros.h"
+
+void test_string_insert_range_exception_safety_throwing_allocator() {
+#if !defined(TEST_HAS_NO_EXCEPTIONS)
+  // Note: the input string must be long enough to prevent SSO, otherwise the allocator won't be used.
+  std::string in(64, 'a');
+
+  try {
+    ThrowingAllocator<char> alloc;
+
+    globalMemCounter.reset();
+    std::basic_string<char, std::char_traits<char>, ThrowingAllocator<char>> c(alloc);
+    c.insert_range(c.end(), in);
+    assert(false); // The function call above should throw.
+
+  } catch (int) {
+    assert(globalMemCounter.new_called == globalMemCounter.delete_called);
+  }
+#endif
+}
+
+// Tested cases:
+// - different kinds of insertions (inserting an {empty/one-element/mid-sized/long range} into an
+//   {empty/one-element/full} container at the {beginning/middle/end});
+// - an exception is thrown when allocating new elements.
+int main(int, char**) {
+  static_assert(test_constraints_insert_range<std::basic_string, char, int>());
+
+  for_all_iterators_and_allocators<char, const char*>([]<class Iter, class Sent, class Alloc>() {
+    test_sequence_insert_range<std::basic_string<char, std::char_traits<char>, Alloc>, Iter, Sent>([](auto&& c) {
+      LIBCPP_ASSERT(c.__invariants());
+    });
+  });
+
+  // Note: `test_insert_range_exception_safety_throwing_copy` doesn't apply because copying chars cannot throw.
+  test_string_insert_range_exception_safety_throwing_allocator();
+
+  return 0;
+}
diff --git a/libcxx/test/std/strings/basic.string/string.modifiers/string_replace/replace_with_range.pass.cpp b/libcxx/test/std/strings/basic.string/string.modifiers/string_replace/replace_with_range.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/strings/basic.string/string.modifiers/string_replace/replace_with_range.pass.cpp
@@ -0,0 +1,743 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+// ADDITIONAL_COMPILE_FLAGS(has-fconstexpr-steps): -fconstexpr-steps=10000000
+
+// template<container-compatible-range<charT> R>
+//   constexpr basic_string& replace_with_range(const_iterator i1, const_iterator i2, R&& rg); // C++23
+
+#include <string>
+
+#include "../../../../containers/sequences/insert_range_sequence_containers.h"
+#include "test_macros.h"
+
+using StrBuffer = Buffer<char, 96>;
+
+struct TestCaseReplacement {
+  StrBuffer initial;
+  std::size_t from = 0;
+  std::size_t to = 0;
+  StrBuffer input;
+  StrBuffer expected;
+};
+
+// Permutation matrix:
+// - initial string: empty / one-element / n elements;
+// - cut starts from: beginning / middle / end;
+// - cut size: empty / one-element / several elements / until the end;
+// - input range: empty / one-element / middle-sized / long.
+
+// Empty string.
+
+constexpr TestCaseReplacement EmptyString_End_EmptyCut_EmptyRange {
+  .initial = "", .from = 0, .to = 0, .input = "", .expected = ""
+};
+
+constexpr TestCaseReplacement EmptyString_End_EmptyCut_OneElementRange {
+  .initial = "", .from = 0, .to = 0, .input = "a", .expected = "a"
+};
+
+constexpr TestCaseReplacement EmptyString_End_EmptyCut_MidRange {
+  .initial = "", .from = 0, .to = 0, .input = "aeiou", .expected = "aeiou"
+};
+
+constexpr TestCaseReplacement EmptyString_End_EmptyCut_LongRange {
+  .initial = "", .from = 0, .to = 0,
+  .input = "abcdefghijklmnopqrstuvwxyz0123456789",
+  .expected = "abcdefghijklmnopqrstuvwxyz0123456789"
+};
+
+// One-element string.
+
+constexpr TestCaseReplacement OneElementString_Begin_EmptyCut_EmptyRange {
+  .initial = "B", .from = 0, .to = 0, .input = "", .expected = "B"
+};
+
+constexpr TestCaseReplacement OneElementString_Begin_EmptyCut_OneElementRange {
+  .initial = "B", .from = 0, .to = 0, .input = "a", .expected = "aB"
+};
+
+constexpr TestCaseReplacement OneElementString_Begin_EmptyCut_MidRange {
+  .initial = "B", .from = 0, .to = 0, .input = "aeiou", .expected = "aeiouB"
+};
+
+constexpr TestCaseReplacement OneElementString_Begin_EmptyCut_LongRange {
+  .initial = "B", .from = 0, .to = 0,
+  .input = "abcdefghijklmnopqrstuvwxyz0123456789",
+  .expected = "abcdefghijklmnopqrstuvwxyz0123456789B"
+};
+
+constexpr TestCaseReplacement OneElementString_Begin_OneElementCut_EmptyRange {
+  .initial = "B", .from = 0, .to = 1, .input = "", .expected = ""
+};
+
+constexpr TestCaseReplacement OneElementString_Begin_OneElementCut_OneElementRange {
+  .initial = "B", .from = 0, .to = 1, .input = "a", .expected = "a"
+};
+
+constexpr TestCaseReplacement OneElementString_Begin_OneElementCut_MidRange {
+  .initial = "B", .from = 0, .to = 1, .input = "aeiou", .expected = "aeiou"
+};
+
+constexpr TestCaseReplacement OneElementString_Begin_OneElementCut_LongRange {
+  .initial = "B", .from = 0, .to = 1,
+  .input = "abcdefghijklmnopqrstuvwxyz0123456789",
+  .expected = "abcdefghijklmnopqrstuvwxyz0123456789"
+};
+
+constexpr TestCaseReplacement OneElementString_End_EmptyCut_EmptyRange {
+  .initial = "B", .from = 1, .to = 1, .input = "", .expected = "B"
+};
+
+constexpr TestCaseReplacement OneElementString_End_EmptyCut_OneElementRange {
+  .initial = "B", .from = 1, .to = 1, .input = "a", .expected = "Ba"
+};
+
+constexpr TestCaseReplacement OneElementString_End_EmptyCut_MidRange {
+  .initial = "B", .from = 1, .to = 1, .input = "aeiou", .expected = "Baeiou"
+};
+
+constexpr TestCaseReplacement OneElementString_End_EmptyCut_LongRange {
+  .initial = "B", .from = 1, .to = 1,
+  .input = "abcdefghijklmnopqrstuvwxyz0123456789",
+  .expected = "Babcdefghijklmnopqrstuvwxyz0123456789"
+};
+
+// Short string (using SSO).
+
+// Replace at the beginning.
+
+constexpr TestCaseReplacement ShortString_Begin_EmptyCut_EmptyRange {
+  .initial = "_BCDFGHJ_", .from = 0, .to = 0, .input = "", .expected = "_BCDFGHJ_"
+};
+
+constexpr TestCaseReplacement ShortString_Begin_EmptyCut_OneElementRange {
+  .initial = "_BCDFGHJ_", .from = 0, .to = 0, .input = "a", .expected = "a_BCDFGHJ_"
+};
+
+constexpr TestCaseReplacement ShortString_Begin_EmptyCut_MidRange {
+  .initial = "_BCDFGHJ_", .from = 0, .to = 0, .input = "aeiou", .expected = "aeiou_BCDFGHJ_"
+};
+
+constexpr TestCaseReplacement ShortString_Begin_EmptyCut_LongRange {
+  .initial = "_BCDFGHJ_", .from = 0, .to = 0,
+  .input = "abcdefghijklmnopqrstuvwxyz0123456789",
+  .expected = "abcdefghijklmnopqrstuvwxyz0123456789_BCDFGHJ_"
+};
+
+constexpr TestCaseReplacement ShortString_Begin_OneElementCut_EmptyRange {
+  .initial = "_BCDFGHJ_", .from = 0, .to = 1, .input = "", .expected = "BCDFGHJ_"
+};
+
+constexpr TestCaseReplacement ShortString_Begin_OneElementCut_OneElementRange {
+  .initial = "_BCDFGHJ_", .from = 0, .to = 1, .input = "a", .expected = "aBCDFGHJ_"
+};
+
+constexpr TestCaseReplacement ShortString_Begin_OneElementCut_MidRange {
+  .initial = "_BCDFGHJ_", .from = 0, .to = 1, .input = "aeiou", .expected = "aeiouBCDFGHJ_"
+};
+
+constexpr TestCaseReplacement ShortString_Begin_OneElementCut_LongRange {
+  .initial = "_BCDFGHJ_", .from = 0, .to = 1,
+  .input = "abcdefghijklmnopqrstuvwxyz0123456789",
+  .expected = "abcdefghijklmnopqrstuvwxyz0123456789BCDFGHJ_"
+};
+
+constexpr TestCaseReplacement ShortString_Begin_MidSizedCut_EmptyRange {
+  .initial = "_BCDFGHJ_", .from = 0, .to = 3, .input = "", .expected = "DFGHJ_"
+};
+
+constexpr TestCaseReplacement ShortString_Begin_MidSizedCut_OneElementRange {
+  .initial = "_BCDFGHJ_", .from = 0, .to = 3, .input = "a", .expected = "aDFGHJ_"
+};
+
+constexpr TestCaseReplacement ShortString_Begin_MidSizedCut_MidRange {
+  .initial = "_BCDFGHJ_", .from = 0, .to = 3, .input = "aeiou", .expected = "aeiouDFGHJ_"
+};
+
+constexpr TestCaseReplacement ShortString_Begin_MidSizedCut_LongRange {
+  .initial = "_BCDFGHJ_", .from = 0, .to = 3,
+  .input = "abcdefghijklmnopqrstuvwxyz0123456789",
+  .expected = "abcdefghijklmnopqrstuvwxyz0123456789DFGHJ_"
+};
+
+constexpr TestCaseReplacement ShortString_Begin_CutToEnd_EmptyRange {
+  .initial = "_BCDFGHJ_", .from = 0, .to = 9, .input = "", .expected = ""
+};
+
+constexpr TestCaseReplacement ShortString_Begin_CutToEnd_OneElementRange {
+  .initial = "_BCDFGHJ_", .from = 0, .to = 9, .input = "a", .expected = "a"
+};
+
+constexpr TestCaseReplacement ShortString_Begin_CutToEnd_MidRange {
+  .initial = "_BCDFGHJ_", .from = 0, .to = 9, .input = "aeiou", .expected = "aeiou"
+};
+
+constexpr TestCaseReplacement ShortString_Begin_CutToEnd_LongRange {
+  .initial = "_BCDFGHJ_", .from = 0, .to = 9,
+  .input = "abcdefghijklmnopqrstuvwxyz0123456789",
+  .expected = "abcdefghijklmnopqrstuvwxyz0123456789"
+};
+
+// Replace in the middle.
+
+constexpr TestCaseReplacement ShortString_Mid_EmptyCut_EmptyRange {
+  .initial = "_BCDFGHJ_", .from = 4, .to = 4, .input = "", .expected = "_BCDFGHJ_"
+};
+
+constexpr TestCaseReplacement ShortString_Mid_EmptyCut_OneElementRange {
+  .initial = "_BCDFGHJ_", .from = 4, .to = 4, .input = "a", .expected = "_BCDaFGHJ_"
+};
+
+constexpr TestCaseReplacement ShortString_Mid_EmptyCut_MidRange {
+  .initial = "_BCDFGHJ_", .from = 4, .to = 4, .input = "aeiou", .expected = "_BCDaeiouFGHJ_"
+};
+
+constexpr TestCaseReplacement ShortString_Mid_EmptyCut_LongRange {
+  .initial = "_BCDFGHJ_", .from = 4, .to = 4,
+  .input = "abcdefghijklmnopqrstuvwxyz0123456789",
+  .expected = "_BCDabcdefghijklmnopqrstuvwxyz0123456789FGHJ_"
+};
+
+constexpr TestCaseReplacement ShortString_Mid_OneElementCut_EmptyRange {
+  .initial = "_BCDFGHJ_", .from = 4, .to = 5, .input = "", .expected = "_BCDGHJ_"
+};
+
+constexpr TestCaseReplacement ShortString_Mid_OneElementCut_OneElementRange {
+  .initial = "_BCDFGHJ_", .from = 4, .to = 5, .input = "a", .expected = "_BCDaGHJ_"
+};
+
+constexpr TestCaseReplacement ShortString_Mid_OneElementCut_MidRange {
+  .initial = "_BCDFGHJ_", .from = 4, .to = 5, .input = "aeiou", .expected = "_BCDaeiouGHJ_"
+};
+
+constexpr TestCaseReplacement ShortString_Mid_OneElementCut_LongRange {
+  .initial = "_BCDFGHJ_", .from = 4, .to = 5,
+  .input = "abcdefghijklmnopqrstuvwxyz0123456789",
+  .expected = "_BCDabcdefghijklmnopqrstuvwxyz0123456789GHJ_"
+};
+
+constexpr TestCaseReplacement ShortString_Mid_MidSizedCut_EmptyRange {
+  .initial = "_BCDFGHJ_", .from = 4, .to = 7, .input = "", .expected = "_BCDJ_"
+};
+
+constexpr TestCaseReplacement ShortString_Mid_MidSizedCut_OneElementRange {
+  .initial = "_BCDFGHJ_", .from = 4, .to = 7, .input = "a", .expected = "_BCDaJ_"
+};
+
+constexpr TestCaseReplacement ShortString_Mid_MidSizedCut_MidRange {
+  .initial = "_BCDFGHJ_", .from = 4, .to = 7, .input = "aeiou", .expected = "_BCDaeiouJ_"
+};
+
+constexpr TestCaseReplacement ShortString_Mid_MidSizedCut_LongRange {
+  .initial = "_BCDFGHJ_", .from = 4, .to = 7,
+  .input = "abcdefghijklmnopqrstuvwxyz0123456789",
+  .expected = "_BCDabcdefghijklmnopqrstuvwxyz0123456789J_"
+};
+
+constexpr TestCaseReplacement ShortString_Mid_CutToEnd_EmptyRange {
+  .initial = "_BCDFGHJ_", .from = 4, .to = 9, .input = "", .expected = "_BCD"
+};
+
+constexpr TestCaseReplacement ShortString_Mid_CutToEnd_OneElementRange {
+  .initial = "_BCDFGHJ_", .from = 4, .to = 9, .input = "a", .expected = "_BCDa"
+};
+
+constexpr TestCaseReplacement ShortString_Mid_CutToEnd_MidRange {
+  .initial = "_BCDFGHJ_", .from = 4, .to = 9, .input = "aeiou", .expected = "_BCDaeiou"
+};
+
+constexpr TestCaseReplacement ShortString_Mid_CutToEnd_LongRange {
+  .initial = "_BCDFGHJ_", .from = 4, .to = 9,
+  .input = "abcdefghijklmnopqrstuvwxyz0123456789",
+  .expected = "_BCDabcdefghijklmnopqrstuvwxyz0123456789"
+};
+
+// Replace at the end.
+
+constexpr TestCaseReplacement ShortString_End_EmptyCut_EmptyRange {
+  .initial = "_BCDFGHJ_", .from = 9, .to = 9, .input = "", .expected = "_BCDFGHJ_"
+};
+
+constexpr TestCaseReplacement ShortString_End_EmptyCut_OneElementRange {
+  .initial = "_BCDFGHJ_", .from = 9, .to = 9, .input = "a", .expected = "_BCDFGHJ_a"
+};
+
+constexpr TestCaseReplacement ShortString_End_EmptyCut_MidRange {
+  .initial = "_BCDFGHJ_", .from = 9, .to = 9, .input = "aeiou", .expected = "_BCDFGHJ_aeiou"
+};
+
+constexpr TestCaseReplacement ShortString_End_EmptyCut_LongRange {
+  .initial = "_BCDFGHJ_", .from = 9, .to = 9,
+  .input = "abcdefghijklmnopqrstuvwxyz0123456789",
+  .expected = "_BCDFGHJ_abcdefghijklmnopqrstuvwxyz0123456789"
+};
+
+// Long string (no SSO).
+
+// Replace at the beginning.
+
+constexpr TestCaseReplacement LongString_Begin_EmptyCut_EmptyRange {
+  .initial = "_ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_", .from = 0, .to = 0, .input = "",
+  .expected = "_ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_"
+};
+
+constexpr TestCaseReplacement LongString_Begin_EmptyCut_OneElementRange {
+  .initial = "_ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_", .from = 0, .to = 0, .input = "a",
+  .expected = "a_ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_"
+};
+
+constexpr TestCaseReplacement LongString_Begin_EmptyCut_MidRange {
+  .initial = "_ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_", .from = 0, .to = 0, .input = "aeiou",
+  .expected = "aeiou_ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_"
+};
+
+constexpr TestCaseReplacement LongString_Begin_EmptyCut_LongRange {
+  .initial = "_ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_", .from = 0, .to = 0,
+  .input = "abcdefghijklmnopqrstuvwxyz0123456789",
+  .expected = "abcdefghijklmnopqrstuvwxyz0123456789_ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_"
+};
+
+constexpr TestCaseReplacement LongString_Begin_OneElementCut_EmptyRange {
+  .initial = "_ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_", .from = 0, .to = 1, .input = "",
+  .expected = "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_"
+};
+
+constexpr TestCaseReplacement LongString_Begin_OneElementCut_OneElementRange {
+  .initial = "_ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_", .from = 0, .to = 1, .input = "a",
+  .expected = "aABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_"
+};
+
+constexpr TestCaseReplacement LongString_Begin_OneElementCut_MidRange {
+  .initial = "_ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_", .from = 0, .to = 1, .input = "aeiou",
+  .expected = "aeiouABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_"
+};
+
+constexpr TestCaseReplacement LongString_Begin_OneElementCut_LongRange {
+  .initial = "_ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_", .from = 0, .to = 1,
+  .input = "abcdefghijklmnopqrstuvwxyz0123456789",
+  .expected = "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_"
+};
+
+constexpr TestCaseReplacement LongString_Begin_MidSizedCut_EmptyRange {
+  .initial = "_ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_", .from = 0, .to = 3, .input = "",
+  .expected = "CDEFGHIJKLMNOPQRSTUVWXYZ0123456789_"
+};
+
+constexpr TestCaseReplacement LongString_Begin_MidSizedCut_OneElementRange {
+  .initial = "_ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_", .from = 0, .to = 3, .input = "a",
+  .expected = "aCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_"
+};
+
+constexpr TestCaseReplacement LongString_Begin_MidSizedCut_MidRange {
+  .initial = "_ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_", .from = 0, .to = 3, .input = "aeiou",
+  .expected = "aeiouCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_"
+};
+
+constexpr TestCaseReplacement LongString_Begin_MidSizedCut_LongRange {
+  .initial = "_ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_", .from = 0, .to = 3,
+  .input = "abcdefghijklmnopqrstuvwxyz0123456789",
+  .expected = "abcdefghijklmnopqrstuvwxyz0123456789CDEFGHIJKLMNOPQRSTUVWXYZ0123456789_"
+};
+
+constexpr TestCaseReplacement LongString_Begin_CutToEnd_EmptyRange {
+  .initial = "_ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_", .from = 0, .to = 38, .input = "",
+  .expected = ""
+};
+
+constexpr TestCaseReplacement LongString_Begin_CutToEnd_OneElementRange {
+  .initial = "_ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_", .from = 0, .to = 38, .input = "a",
+  .expected = "a"
+};
+
+constexpr TestCaseReplacement LongString_Begin_CutToEnd_MidRange {
+  .initial = "_ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_", .from = 0, .to = 38, .input = "aeiou",
+  .expected = "aeiou"
+};
+
+constexpr TestCaseReplacement LongString_Begin_CutToEnd_LongRange {
+  .initial = "_ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_", .from = 0, .to = 38,
+  .input = "abcdefghijklmnopqrstuvwxyz0123456789",
+  .expected = "abcdefghijklmnopqrstuvwxyz0123456789"
+};
+
+// Replace in the middle.
+
+constexpr TestCaseReplacement LongString_Mid_EmptyCut_EmptyRange {
+  .initial = "_ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_", .from = 18, .to = 18, .input = "",
+  .expected = "_ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_"
+};
+
+constexpr TestCaseReplacement LongString_Mid_EmptyCut_OneElementRange {
+  .initial = "_ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_", .from = 18, .to = 18, .input = "a",
+  .expected = "_ABCDEFGHIJKLMNOPQaRSTUVWXYZ0123456789_"
+};
+
+constexpr TestCaseReplacement LongString_Mid_EmptyCut_MidRange {
+  .initial = "_ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_", .from = 18, .to = 18, .input = "aeiou",
+  .expected = "_ABCDEFGHIJKLMNOPQaeiouRSTUVWXYZ0123456789_"
+};
+
+constexpr TestCaseReplacement LongString_Mid_EmptyCut_LongRange {
+  .initial = "_ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_", .from = 18, .to = 18,
+  .input = "abcdefghijklmnopqrstuvwxyz0123456789",
+  .expected = "_ABCDEFGHIJKLMNOPQabcdefghijklmnopqrstuvwxyz0123456789RSTUVWXYZ0123456789_"
+};
+
+constexpr TestCaseReplacement LongString_Mid_OneElementCut_EmptyRange {
+  .initial = "_ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_", .from = 18, .to = 19, .input = "",
+  .expected = "_ABCDEFGHIJKLMNOPQSTUVWXYZ0123456789_"
+};
+
+constexpr TestCaseReplacement LongString_Mid_OneElementCut_OneElementRange {
+  .initial = "_ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_", .from = 18, .to = 19, .input = "a",
+  .expected = "_ABCDEFGHIJKLMNOPQaSTUVWXYZ0123456789_"
+};
+
+constexpr TestCaseReplacement LongString_Mid_OneElementCut_MidRange {
+  .initial = "_ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_", .from = 18, .to = 19, .input = "aeiou",
+  .expected = "_ABCDEFGHIJKLMNOPQaeiouSTUVWXYZ0123456789_"
+};
+
+constexpr TestCaseReplacement LongString_Mid_OneElementCut_LongRange {
+  .initial = "_ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_", .from = 18, .to = 19,
+  .input = "abcdefghijklmnopqrstuvwxyz0123456789",
+  .expected = "_ABCDEFGHIJKLMNOPQabcdefghijklmnopqrstuvwxyz0123456789STUVWXYZ0123456789_"
+};
+
+constexpr TestCaseReplacement LongString_Mid_MidSizedCut_EmptyRange {
+  .initial = "_ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_", .from = 18, .to = 21, .input = "",
+  .expected = "_ABCDEFGHIJKLMNOPQUVWXYZ0123456789_"
+};
+
+constexpr TestCaseReplacement LongString_Mid_MidSizedCut_OneElementRange {
+  .initial = "_ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_", .from = 18, .to = 21, .input = "a",
+  .expected = "_ABCDEFGHIJKLMNOPQaUVWXYZ0123456789_"
+};
+
+constexpr TestCaseReplacement LongString_Mid_MidSizedCut_MidRange {
+  .initial = "_ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_", .from = 18, .to = 21, .input = "aeiou",
+  .expected = "_ABCDEFGHIJKLMNOPQaeiouUVWXYZ0123456789_"
+};
+
+constexpr TestCaseReplacement LongString_Mid_MidSizedCut_LongRange {
+  .initial = "_ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_", .from = 18, .to = 21,
+  .input = "abcdefghijklmnopqrstuvwxyz0123456789",
+  .expected = "_ABCDEFGHIJKLMNOPQabcdefghijklmnopqrstuvwxyz0123456789UVWXYZ0123456789_"
+};
+
+constexpr TestCaseReplacement LongString_Mid_CutToEnd_EmptyRange {
+  .initial = "_ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_", .from = 18, .to = 38, .input = "",
+  .expected = "_ABCDEFGHIJKLMNOPQ"
+};
+
+constexpr TestCaseReplacement LongString_Mid_CutToEnd_OneElementRange {
+  .initial = "_ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_", .from = 18, .to = 38, .input = "a",
+  .expected = "_ABCDEFGHIJKLMNOPQa"
+};
+
+constexpr TestCaseReplacement LongString_Mid_CutToEnd_MidRange {
+  .initial = "_ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_", .from = 18, .to = 38, .input = "aeiou",
+  .expected = "_ABCDEFGHIJKLMNOPQaeiou"
+};
+
+constexpr TestCaseReplacement LongString_Mid_CutToEnd_LongRange {
+  .initial = "_ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_", .from = 18, .to = 38,
+  .input = "abcdefghijklmnopqrstuvwxyz0123456789",
+  .expected = "_ABCDEFGHIJKLMNOPQabcdefghijklmnopqrstuvwxyz0123456789"
+};
+
+// Replace at the end.
+
+constexpr TestCaseReplacement LongString_End_EmptyCut_EmptyRange {
+  .initial = "_ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_", .from = 38, .to = 38, .input = "",
+  .expected = "_ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_"
+};
+
+constexpr TestCaseReplacement LongString_End_EmptyCut_OneElementRange {
+  .initial = "_ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_", .from = 38, .to = 38, .input = "a",
+  .expected = "_ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_a"
+};
+
+constexpr TestCaseReplacement LongString_End_EmptyCut_MidRange {
+  .initial = "_ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_", .from = 38, .to = 38, .input = "aeiou",
+  .expected = "_ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_aeiou"
+};
+
+constexpr TestCaseReplacement LongString_End_EmptyCut_LongRange {
+  .initial = "_ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_", .from = 38, .to = 38,
+  .input = "abcdefghijklmnopqrstuvwxyz0123456789",
+  .expected = "_ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_abcdefghijklmnopqrstuvwxyz0123456789"
+};
+
+template <class Iter, class Sent, class Alloc>
+constexpr void test_string_replace_with_range() {
+  auto test = [&](const TestCaseReplacement& test_case) {
+    using Container = std::basic_string<char, std::char_traits<char>, Alloc>;
+
+    auto get_pos = [](auto& c, auto index) { return std::ranges::next(c.begin(), index); };
+    Container c(test_case.initial.begin(), test_case.initial.end());
+    auto in = wrap_input<Iter, Sent>(test_case.input);
+    auto from = get_pos(c, test_case.from);
+    auto to = get_pos(c, test_case.to);
+
+    Container& result = c.replace_with_range(from, to, in);
+    assert(&result == &c);
+    LIBCPP_ASSERT(c.__invariants());
+    return std::ranges::equal(c, test_case.expected);
+  };
+
+  { // Empty string.
+    // empty_str.replace_with_range(end, end, empty_range)
+    assert(test(EmptyString_End_EmptyCut_EmptyRange));
+    // empty_str.replace_with_range(end, end, one_element_range)
+    assert(test(EmptyString_End_EmptyCut_OneElementRange));
+    // empty_str.replace_with_range(end, end, mid_range)
+    assert(test(EmptyString_End_EmptyCut_MidRange));
+    // empty_str.replace_with_range(end, end, long_range)
+    assert(test(EmptyString_End_EmptyCut_LongRange));
+  }
+
+  { // One-element string.
+    // one_element_str.replace_with_range(begin, begin, empty_range)
+    assert(test(OneElementString_Begin_EmptyCut_EmptyRange));
+    // one_element_str.replace_with_range(begin, begin, one_element_range)
+    assert(test(OneElementString_Begin_EmptyCut_OneElementRange));
+    // one_element_str.replace_with_range(begin, begin, mid_range)
+    assert(test(OneElementString_Begin_EmptyCut_MidRange));
+    // one_element_str.replace_with_range(begin, begin, long_range)
+    assert(test(OneElementString_Begin_EmptyCut_LongRange));
+    // one_element_str.replace_with_range(begin, begin + 1, empty_range)
+    assert(test(OneElementString_Begin_OneElementCut_EmptyRange));
+    // one_element_str.replace_with_range(begin, begin + 1, one_element_range)
+    assert(test(OneElementString_Begin_OneElementCut_OneElementRange));
+    // one_element_str.replace_with_range(begin, begin + 1, mid_range)
+    assert(test(OneElementString_Begin_OneElementCut_MidRange));
+    // one_element_str.replace_with_range(begin, begin + 1, long_range)
+    assert(test(OneElementString_Begin_OneElementCut_LongRange));
+    // one_element_str.replace_with_range(end, end, empty_range)
+    assert(test(OneElementString_End_EmptyCut_EmptyRange));
+    // one_element_str.replace_with_range(end, end, one_element_range)
+    assert(test(OneElementString_End_EmptyCut_OneElementRange));
+    // one_element_str.replace_with_range(end, end, mid_range)
+    assert(test(OneElementString_End_EmptyCut_MidRange));
+    // one_element_str.replace_with_range(end, end, long_range)
+    assert(test(OneElementString_End_EmptyCut_LongRange));
+  }
+
+  { // Short string.
+    // Replace at the beginning.
+
+    // short_str.replace_with_range(begin, begin, empty_range)
+    assert(test(ShortString_Begin_EmptyCut_EmptyRange));
+    // short_str.replace_with_range(begin, begin, one_element_range)
+    assert(test(ShortString_Begin_EmptyCut_OneElementRange));
+    // short_str.replace_with_range(begin, begin, mid_range)
+    assert(test(ShortString_Begin_EmptyCut_MidRange));
+    // short_str.replace_with_range(begin, begin, long_range)
+    assert(test(ShortString_Begin_EmptyCut_LongRange));
+    // short_str.replace_with_range(begin, begin + 1, empty_range)
+    assert(test(ShortString_Begin_OneElementCut_EmptyRange));
+    // short_str.replace_with_range(begin, begin + 1, one_element_range)
+    assert(test(ShortString_Begin_OneElementCut_OneElementRange));
+    // short_str.replace_with_range(begin, begin + 1, mid_range)
+    assert(test(ShortString_Begin_OneElementCut_MidRange));
+    // short_str.replace_with_range(begin, begin + 1, long_range)
+    assert(test(ShortString_Begin_OneElementCut_LongRange));
+    // short_str.replace_with_range(begin, begin + 3, empty_range)
+    assert(test(ShortString_Begin_MidSizedCut_EmptyRange));
+    // short_str.replace_with_range(begin, begin + 3, one_element_range)
+    assert(test(ShortString_Begin_MidSizedCut_OneElementRange));
+    // short_str.replace_with_range(begin, begin + 3, mid_range)
+    assert(test(ShortString_Begin_MidSizedCut_MidRange));
+    // short_str.replace_with_range(begin, begin + 3, long_range)
+    assert(test(ShortString_Begin_MidSizedCut_LongRange));
+    // short_str.replace_with_range(begin, end, empty_range)
+    assert(test(ShortString_Begin_CutToEnd_EmptyRange));
+    // short_str.replace_with_range(begin, end, one_element_range)
+    assert(test(ShortString_Begin_CutToEnd_OneElementRange));
+    // short_str.replace_with_range(begin, end, mid_range)
+    assert(test(ShortString_Begin_CutToEnd_MidRange));
+    // short_str.replace_with_range(begin, end, long_range)
+    assert(test(ShortString_Begin_CutToEnd_LongRange));
+
+    // Replace in the middle.
+
+    // short_str.replace_with_range(mid, mid, empty_range)
+    assert(test(ShortString_Mid_EmptyCut_EmptyRange));
+    // short_str.replace_with_range(mid, mid, one_element_range)
+    assert(test(ShortString_Mid_EmptyCut_OneElementRange));
+    // short_str.replace_with_range(mid, mid, mid_range)
+    assert(test(ShortString_Mid_EmptyCut_MidRange));
+    // short_str.replace_with_range(mid, mid, long_range)
+    assert(test(ShortString_Mid_EmptyCut_LongRange));
+    // short_str.replace_with_range(mid, mid + 1, empty_range)
+    assert(test(ShortString_Mid_OneElementCut_EmptyRange));
+    // short_str.replace_with_range(mid, mid + 1, one_element_range)
+    assert(test(ShortString_Mid_OneElementCut_OneElementRange));
+    // short_str.replace_with_range(mid, mid + 1, mid_range)
+    assert(test(ShortString_Mid_OneElementCut_MidRange));
+    // short_str.replace_with_range(mid, mid + 1, long_range)
+    assert(test(ShortString_Mid_OneElementCut_LongRange));
+    // short_str.replace_with_range(mid, mid + 3, empty_range)
+    assert(test(ShortString_Mid_MidSizedCut_EmptyRange));
+    // short_str.replace_with_range(mid, mid + 3, one_element_range)
+    assert(test(ShortString_Mid_MidSizedCut_OneElementRange));
+    // short_str.replace_with_range(mid, mid + 3, mid_range)
+    assert(test(ShortString_Mid_MidSizedCut_MidRange));
+    // short_str.replace_with_range(mid, mid + 3, long_range)
+    assert(test(ShortString_Mid_MidSizedCut_LongRange));
+    // short_str.replace_with_range(mid, end, empty_range)
+    assert(test(ShortString_Mid_CutToEnd_EmptyRange));
+    // short_str.replace_with_range(mid, end, one_element_range)
+    assert(test(ShortString_Mid_CutToEnd_OneElementRange));
+    // short_str.replace_with_range(mid, end, mid_range)
+    assert(test(ShortString_Mid_CutToEnd_MidRange));
+    // short_str.replace_with_range(mid, end, long_range)
+    assert(test(ShortString_Mid_CutToEnd_LongRange));
+
+    // Replace at the end.
+
+    // short_str.replace_with_range(end, end, empty_range)
+    assert(test(ShortString_End_EmptyCut_EmptyRange));
+    // short_str.replace_with_range(end, end, one_element_range)
+    assert(test(ShortString_End_EmptyCut_OneElementRange));
+    // short_str.replace_with_range(end, end, mid_range)
+    assert(test(ShortString_End_EmptyCut_MidRange));
+    // short_str.replace_with_range(end, end, long_range)
+    assert(test(ShortString_End_EmptyCut_LongRange));
+  }
+
+  { // Long string.
+    // Replace at the beginning.
+
+    // long_str.replace_with_range(begin, begin, empty_range)
+    assert(test(LongString_Begin_EmptyCut_EmptyRange));
+    // long_str.replace_with_range(begin, begin, one_element_range)
+    assert(test(LongString_Begin_EmptyCut_OneElementRange));
+    // long_str.replace_with_range(begin, begin, mid_range)
+    assert(test(LongString_Begin_EmptyCut_MidRange));
+    // long_str.replace_with_range(begin, begin, long_range)
+    assert(test(LongString_Begin_EmptyCut_LongRange));
+    // long_str.replace_with_range(begin, begin + 1, empty_range)
+    assert(test(LongString_Begin_OneElementCut_EmptyRange));
+    // long_str.replace_with_range(begin, begin + 1, one_element_range)
+    assert(test(LongString_Begin_OneElementCut_OneElementRange));
+    // long_str.replace_with_range(begin, begin + 1, mid_range)
+    assert(test(LongString_Begin_OneElementCut_MidRange));
+    // long_str.replace_with_range(begin, begin + 1, long_range)
+    assert(test(LongString_Begin_OneElementCut_LongRange));
+    // long_str.replace_with_range(begin, begin + 3, empty_range)
+    assert(test(LongString_Begin_MidSizedCut_EmptyRange));
+    // long_str.replace_with_range(begin, begin + 3, one_element_range)
+    assert(test(LongString_Begin_MidSizedCut_OneElementRange));
+    // long_str.replace_with_range(begin, begin + 3, mid_range)
+    assert(test(LongString_Begin_MidSizedCut_MidRange));
+    // long_str.replace_with_range(begin, begin + 3, long_range)
+    assert(test(LongString_Begin_MidSizedCut_LongRange));
+    // long_str.replace_with_range(begin, end, empty_range)
+    assert(test(LongString_Begin_CutToEnd_EmptyRange));
+    // long_str.replace_with_range(begin, end, one_element_range)
+    assert(test(LongString_Begin_CutToEnd_OneElementRange));
+    // long_str.replace_with_range(begin, end, mid_range)
+    assert(test(LongString_Begin_CutToEnd_MidRange));
+    // long_str.replace_with_range(begin, end, long_range)
+    assert(test(LongString_Begin_CutToEnd_LongRange));
+
+    // Replace in the middle.
+
+    // long_str.replace_with_range(mid, mid, empty_range)
+    assert(test(LongString_Mid_EmptyCut_EmptyRange));
+    // long_str.replace_with_range(mid, mid, one_element_range)
+    assert(test(LongString_Mid_EmptyCut_OneElementRange));
+    // long_str.replace_with_range(mid, mid, mid_range)
+    assert(test(LongString_Mid_EmptyCut_MidRange));
+    // long_str.replace_with_range(mid, mid, long_range)
+    assert(test(LongString_Mid_EmptyCut_LongRange));
+    // long_str.replace_with_range(mid, mid + 1, empty_range)
+    assert(test(LongString_Mid_OneElementCut_EmptyRange));
+    // long_str.replace_with_range(mid, mid + 1, one_element_range)
+    assert(test(LongString_Mid_OneElementCut_OneElementRange));
+    // long_str.replace_with_range(mid, mid + 1, mid_range)
+    assert(test(LongString_Mid_OneElementCut_MidRange));
+    // long_str.replace_with_range(mid, mid + 1, long_range)
+    assert(test(LongString_Mid_OneElementCut_LongRange));
+    // long_str.replace_with_range(mid, mid + 3, empty_range)
+    assert(test(LongString_Mid_MidSizedCut_EmptyRange));
+    // long_str.replace_with_range(mid, mid + 3, one_element_range)
+    assert(test(LongString_Mid_MidSizedCut_OneElementRange));
+    // long_str.replace_with_range(mid, mid + 3, mid_range)
+    assert(test(LongString_Mid_MidSizedCut_MidRange));
+    // long_str.replace_with_range(mid, mid + 3, long_range)
+    assert(test(LongString_Mid_MidSizedCut_LongRange));
+    // long_str.replace_with_range(mid, end, empty_range)
+    assert(test(LongString_Mid_CutToEnd_EmptyRange));
+    // long_str.replace_with_range(mid, end, one_element_range)
+    assert(test(LongString_Mid_CutToEnd_OneElementRange));
+    // long_str.replace_with_range(mid, end, mid_range)
+    assert(test(LongString_Mid_CutToEnd_MidRange));
+    // long_str.replace_with_range(mid, end, long_range)
+    assert(test(LongString_Mid_CutToEnd_LongRange));
+
+    // Replace at the end.
+
+    // long_str.replace_with_range(end, end, empty_range)
+    assert(test(LongString_End_EmptyCut_EmptyRange));
+    // long_str.replace_with_range(end, end, one_element_range)
+    assert(test(LongString_End_EmptyCut_OneElementRange));
+    // long_str.replace_with_range(end, end, mid_range)
+    assert(test(LongString_End_EmptyCut_MidRange));
+    // long_str.replace_with_range(end, end, long_range)
+    assert(test(LongString_End_EmptyCut_LongRange));
+  }
+}
+
+void test_string_replace_with_range_exception_safety_throwing_allocator() {
+#if !defined(TEST_HAS_NO_EXCEPTIONS)
+  // Note: the input string must be long enough to prevent SSO, otherwise the allocator won't be used.
+  std::string in(64, 'a');
+
+  try {
+    ThrowingAllocator<char> alloc;
+
+    globalMemCounter.reset();
+    std::basic_string<char, std::char_traits<char>, ThrowingAllocator<char>> c(alloc);
+    c.replace_with_range(c.end(), c.end(), in);
+    assert(false); // The function call above should throw.
+
+  } catch (int) {
+    assert(globalMemCounter.new_called == globalMemCounter.delete_called);
+  }
+#endif
+}
+
+constexpr bool test_constexpr() {
+  for_all_iterators_and_allocators_constexpr<char, const char*>([]<class Iter, class Sent, class Alloc>() {
+    test_string_replace_with_range<Iter, Sent, Alloc>();
+  });
+
+  return true;
+}
+
+// Tested cases:
+// - different kinds of replacements (varying the size of the initial string, the cut point and the cut size, and the
+//   size of the input range);
+// - an exception is thrown when allocating new elements.
+int main(int, char**) {
+  for_all_iterators_and_allocators_constexpr<char, const char*>([]<class Iter, class Sent, class Alloc>() {
+    test_string_replace_with_range<Iter, Sent, Alloc>();
+  });
+  static_assert(test_constexpr());
+
+  // Note: `test_string_replace_with_range_exception_safety_throwing_copy` doesn't apply because copying chars cannot
+  // throw.
+  test_string_replace_with_range_exception_safety_throwing_allocator();
+
+  return 0;
+}
diff --git a/libcxx/test/std/strings/basic.string/string.modifiers/string_replace/size_size_string_size_size.pass.cpp b/libcxx/test/std/strings/basic.string/string.modifiers/string_replace/size_size_string_size_size.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.modifiers/string_replace/size_size_string_size_size.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.modifiers/string_replace/size_size_string_size_size.pass.cpp
@@ -1,5 +1,5 @@
-//===----------------------------------------------------------------------===//
 //
+//===----------------------------------------------------------------------===//
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
diff --git a/libcxx/test/support/deduction_guides_sfinae_checks.h b/libcxx/test/support/deduction_guides_sfinae_checks.h
--- a/libcxx/test/support/deduction_guides_sfinae_checks.h
+++ b/libcxx/test/support/deduction_guides_sfinae_checks.h
@@ -18,6 +18,25 @@
 #include <utility>
 
 #include "test_macros.h"
+#if TEST_STD_VER >= 23
+#include "almost_satisfies_types.h"
+#endif
+
+#if TEST_STD_VER >= 23
+
+template <class T>
+struct RangeT {
+  T* begin();
+  T* end();
+};
+static_assert(std::ranges::input_range<RangeT<int>>);
+
+template <class T>
+using BadRangeT = InputRangeNotDerivedFromGeneric<T>;
+static_assert(std::ranges::range<BadRangeT<int>>);
+static_assert(!std::ranges::input_range<BadRangeT<int>>);
+
+#endif
 
 // `SFINAEs_away` template variable checks whether the template arguments for
 // a given template class `Instantiated` can be deduced from the given
@@ -34,17 +53,20 @@
 constexpr bool SFINAEs_away =
     decltype(SFINAEs_away_impl<Instantiated, CtrArgs...>(0))::value;
 
+struct Empty {};
+
 // For sequence containers the deduction guides should be SFINAE'd away when
 // given:
 // - "bad" input iterators (that is, a type not qualifying as an input
 //   iterator);
-// - a bad allocator.
-template<template<typename ...> class Container, typename InstantiatedContainer>
+// - a bad allocator;
+// - a range not satisfying the `input_range` concept.
+template<template<typename ...> class Container, typename InstantiatedContainer, typename BadAlloc = Empty>
 constexpr void SequenceContainerDeductionGuidesSfinaeAway() {
-  using Alloc = std::allocator<int>;
-  using Iter = int*;
+  using T = typename InstantiatedContainer::value_type;
+  using Alloc = std::allocator<T>;
+  using Iter = T*;
 
-  struct BadAlloc {};
   // Note: the only requirement in the Standard is that integral types cannot be
   // considered input iterators; however, this doesn't work for sequence
   // containers because they have constructors of the form `(size_type count,
@@ -70,6 +92,20 @@
   //
   // Cannot deduce from (alloc)
   static_assert(SFINAEs_away<Container, Alloc>);
+
+#if TEST_STD_VER >= 23
+  using BadRange = BadRangeT<T>;
+
+  // (from_range, range)
+  //
+  // Cannot deduce from (BAD_range)
+  static_assert(SFINAEs_away<Container, std::from_range_t, BadRange>);
+
+  // (from_range, range, alloc)
+  //
+  // Cannot deduce from (range, BAD_alloc)
+  static_assert(SFINAEs_away<Container, std::from_range_t, RangeT<int>, BadAlloc>);
+#endif
 }
 
 // For associative containers the deduction guides should be SFINAE'd away when