diff --git a/cross-project-tests/debuginfo-tests/llvm-prettyprinters/gdb/mlir-support.cpp b/cross-project-tests/debuginfo-tests/llvm-prettyprinters/gdb/mlir-support.cpp
--- a/cross-project-tests/debuginfo-tests/llvm-prettyprinters/gdb/mlir-support.cpp
+++ b/cross-project-tests/debuginfo-tests/llvm-prettyprinters/gdb/mlir-support.cpp
@@ -9,9 +9,9 @@
 
 auto Identifier = mlir::Identifier::get("foo", &Context);
 mlir::OperationName OperationName("FooOp", &Context);
-mlir::Value Value({reinterpret_cast<void *>(0x8),
+/*mlir::Value Value({reinterpret_cast<void *>(0x8),
                    mlir::Value::Kind::TrailingOpResult});
-
+*/
 mlir::Type Type(nullptr);
 mlir::Type IndexType = mlir::IndexType::get(&Context);
 mlir::Type IntegerType =
diff --git a/libcxx/docs/Status/Cxx20Papers.csv b/libcxx/docs/Status/Cxx20Papers.csv
--- a/libcxx/docs/Status/Cxx20Papers.csv
+++ b/libcxx/docs/Status/Cxx20Papers.csv
@@ -106,7 +106,7 @@
 "`P0645R10 <https://wg21.link/P0645R10>`__","LWG","Text Formatting","Cologne","|In Progress|",""
 "`P0660R10 <https://wg21.link/P0660R10>`__","LWG","Stop Token and Joining Thread, Rev 10","Cologne","",""
 "`P0784R7 <https://wg21.link/P0784R7>`__","CWG","More constexpr containers","Cologne","|Complete|","12.0"
-"`P0980R1 <https://wg21.link/P0980R1>`__","LWG","Making std::string constexpr","Cologne","",""
+"`P0980R1 <https://wg21.link/P0980R1>`__","LWG","Making std::string constexpr","Cologne","|Complete|","14.0"
 "`P1004R2 <https://wg21.link/P1004R2>`__","LWG","Making std::vector constexpr","Cologne","",""
 "`P1035R7 <https://wg21.link/P1035R7>`__","LWG","Input Range Adaptors","Cologne","",""
 "`P1065R2 <https://wg21.link/P1065R2>`__","LWG","Constexpr INVOKE","Cologne","|Complete|","12.0"
diff --git a/libcxx/include/__memory/compressed_pair.h b/libcxx/include/__memory/compressed_pair.h
--- a/libcxx/include/__memory/compressed_pair.h
+++ b/libcxx/include/__memory/compressed_pair.h
@@ -58,10 +58,8 @@
       : __value_(_VSTD::forward<_Args>(_VSTD::get<_Indexes>(__args))...) {}
 #endif
 
-
-  _LIBCPP_INLINE_VISIBILITY reference __get() _NOEXCEPT { return __value_; }
-  _LIBCPP_INLINE_VISIBILITY
-  const_reference __get() const _NOEXCEPT { return __value_; }
+  _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 reference __get() _NOEXCEPT { return __value_; }
+  _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR const_reference __get() const _NOEXCEPT { return __value_; }
 
 private:
   _Tp __value_;
@@ -97,9 +95,8 @@
       : __value_type(_VSTD::forward<_Args>(_VSTD::get<_Indexes>(__args))...) {}
 #endif
 
-  _LIBCPP_INLINE_VISIBILITY reference __get() _NOEXCEPT { return *this; }
-  _LIBCPP_INLINE_VISIBILITY
-  const_reference __get() const _NOEXCEPT { return *this; }
+  _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 reference __get() _NOEXCEPT { return *this; }
+  _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR const_reference __get() const _NOEXCEPT { return *this; }
 };
 
 template <class _T1, class _T2>
@@ -143,23 +140,19 @@
                typename __make_tuple_indices<sizeof...(_Args2)>::type()) {}
 #endif
 
-  _LIBCPP_INLINE_VISIBILITY
-  typename _Base1::reference first() _NOEXCEPT {
+  _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 typename _Base1::reference first() _NOEXCEPT {
     return static_cast<_Base1&>(*this).__get();
   }
 
-  _LIBCPP_INLINE_VISIBILITY
-  typename _Base1::const_reference first() const _NOEXCEPT {
+  _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR typename _Base1::const_reference first() const _NOEXCEPT {
     return static_cast<_Base1 const&>(*this).__get();
   }
 
-  _LIBCPP_INLINE_VISIBILITY
-  typename _Base2::reference second() _NOEXCEPT {
+  _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 typename _Base2::reference second() _NOEXCEPT {
     return static_cast<_Base2&>(*this).__get();
   }
 
-  _LIBCPP_INLINE_VISIBILITY
-  typename _Base2::const_reference second() const _NOEXCEPT {
+  _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR typename _Base2::const_reference second() const _NOEXCEPT {
     return static_cast<_Base2 const&>(*this).__get();
   }
 
diff --git a/libcxx/include/__string b/libcxx/include/__string
--- a/libcxx/include/__string
+++ b/libcxx/include/__string
@@ -293,22 +293,25 @@
 
 template <class _CharT>
 static inline _LIBCPP_CONSTEXPR_AFTER_CXX17
-_CharT* __move_constexpr(_CharT* __s1, const _CharT* __s2, size_t __n) _NOEXCEPT
+_CharT* __copy_constexpr(_CharT* __s1, const _CharT* __s2, size_t __n) _NOEXCEPT
 {
-    if (__n == 0) return __s1;
-    if (__s1 < __s2) {
-      _VSTD::copy(__s2, __s2 + __n, __s1);
-    } else if (__s2 < __s1) {
-      _VSTD::copy_backward(__s2, __s2 + __n, __s1 + __n);
-    }
+    _LIBCPP_ASSERT(__libcpp_is_constant_evaluated(), 
+                   "__copy_constexpr should always be constant evaluated");
+    _VSTD::copy_n(__s2, __n, __s1);
     return __s1;
 }
 
 template <class _CharT>
 static inline _LIBCPP_CONSTEXPR_AFTER_CXX17
-_CharT* __copy_constexpr(_CharT* __s1, const _CharT* __s2, size_t __n) _NOEXCEPT
+_CharT* __move_constexpr(_CharT* __s1, const _CharT* __s2, size_t __n) _NOEXCEPT
 {
-    _VSTD::copy_n(__s2, __n, __s1);
+    _LIBCPP_ASSERT(__libcpp_is_constant_evaluated(), 
+                   "__move_constexpr should always be constant evaluated");
+    if (__n == 0) return __s1;
+    _CharT* __alloc = new _CharT[__n];
+    _VSTD::__copy_constexpr(__alloc, __s2, __n);
+    _VSTD::__copy_constexpr(__s1, static_cast<const _CharT*>(__alloc), __n);
+    delete[] __alloc;
     return __s1;
 }
 
@@ -316,6 +319,8 @@
 static inline _LIBCPP_CONSTEXPR_AFTER_CXX17
 _CharT* __assign_constexpr(_CharT* __s, size_t __n, _CharT __a) _NOEXCEPT
 {
+    _LIBCPP_ASSERT(__libcpp_is_constant_evaluated(), 
+                   "__move_constexpr should always be constant evaluated");
      _VSTD::fill_n(__s, __n, __a);
      return __s;
 }
@@ -334,14 +339,24 @@
     static inline _LIBCPP_CONSTEXPR_AFTER_CXX14
     void assign(char_type& __c1, const char_type& __c2) _NOEXCEPT {__c1 = __c2;}
     static inline _LIBCPP_CONSTEXPR bool eq(char_type __c1, char_type __c2) _NOEXCEPT
-            {return __c1 == __c2;}
+        {return __c1 == __c2;}
     static inline _LIBCPP_CONSTEXPR bool lt(char_type __c1, char_type __c2) _NOEXCEPT
         {return (unsigned char)__c1 < (unsigned char)__c2;}
 
     static _LIBCPP_CONSTEXPR_AFTER_CXX14
     int compare(const char_type* __s1, const char_type* __s2, size_t __n) _NOEXCEPT;
-    static inline size_t _LIBCPP_CONSTEXPR_AFTER_CXX14
-    length(const char_type* __s)  _NOEXCEPT {return __builtin_strlen(__s);}
+
+    static inline size_t _LIBCPP_CONSTEXPR_AFTER_CXX14 length(const char_type* __s)  _NOEXCEPT {
+#ifdef _LIBCPP_COMPILER_GCC
+      if (__libcpp_is_constant_evaluated()) {
+        size_t i = 0;
+        for (; __s[i] != '\0'; ++i) ;
+        return i;
+      }
+#endif
+      return __builtin_strlen(__s);
+    }
+
     static _LIBCPP_CONSTEXPR_AFTER_CXX14
     const char_type* find(const char_type* __s, size_t __n, const char_type& __a) _NOEXCEPT;
     static inline _LIBCPP_CONSTEXPR_AFTER_CXX17
diff --git a/libcxx/include/memory b/libcxx/include/memory
--- a/libcxx/include/memory
+++ b/libcxx/include/memory
@@ -669,6 +669,7 @@
 
 */
 
+#include "__config"
 #include <__config>
 #include <__functional_base>
 #include <__memory/addressof.h>
@@ -840,7 +841,7 @@
 
 // --- Helper for container swap --
 template <typename _Alloc>
-_LIBCPP_INLINE_VISIBILITY
+_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
 void __swap_allocator(_Alloc & __a1, _Alloc & __a2, true_type)
 #if _LIBCPP_STD_VER >= 14
     _NOEXCEPT
@@ -853,11 +854,11 @@
 }
 
 template <typename _Alloc>
-inline _LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
 void __swap_allocator(_Alloc &, _Alloc &, false_type) _NOEXCEPT {}
 
 template <typename _Alloc>
-inline _LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
 void __swap_allocator(_Alloc & __a1, _Alloc & __a2)
 #if _LIBCPP_STD_VER >= 14
     _NOEXCEPT
diff --git a/libcxx/include/string b/libcxx/include/string
--- a/libcxx/include/string
+++ b/libcxx/include/string
@@ -519,6 +519,7 @@
 #include <__debug>
 #include <__functional_base>
 #include <__iterator/wrap_iter.h>
+#include <__memory/construct_at.h>
 #include <algorithm>
 #include <compare>
 #include <cstdio>  // EOF
@@ -592,24 +593,28 @@
 // basic_string
 
 template<class _CharT, class _Traits, class _Allocator>
+_LIBCPP_CONSTEXPR_AFTER_CXX17
 basic_string<_CharT, _Traits, _Allocator>
 operator+(const basic_string<_CharT, _Traits, _Allocator>& __x,
           const basic_string<_CharT, _Traits, _Allocator>& __y);
 
 template<class _CharT, class _Traits, class _Allocator>
+_LIBCPP_CONSTEXPR_AFTER_CXX17
 basic_string<_CharT, _Traits, _Allocator>
 operator+(const _CharT* __x, const basic_string<_CharT,_Traits,_Allocator>& __y);
 
 template<class _CharT, class _Traits, class _Allocator>
+_LIBCPP_CONSTEXPR_AFTER_CXX17
 basic_string<_CharT, _Traits, _Allocator>
 operator+(_CharT __x, const basic_string<_CharT,_Traits,_Allocator>& __y);
 
 template<class _CharT, class _Traits, class _Allocator>
-inline _LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
 basic_string<_CharT, _Traits, _Allocator>
 operator+(const basic_string<_CharT, _Traits, _Allocator>& __x, const _CharT* __y);
 
 template<class _CharT, class _Traits, class _Allocator>
+_LIBCPP_CONSTEXPR_AFTER_CXX17
 basic_string<_CharT, _Traits, _Allocator>
 operator+(const basic_string<_CharT, _Traits, _Allocator>& __x, _CharT __y);
 
@@ -703,8 +708,8 @@
 
     typedef __wrap_iter<pointer>                         iterator;
     typedef __wrap_iter<const_pointer>                   const_iterator;
-    typedef _VSTD::reverse_iterator<iterator>             reverse_iterator;
-    typedef _VSTD::reverse_iterator<const_iterator>       const_reverse_iterator;
+    typedef _VSTD::reverse_iterator<iterator>            reverse_iterator;
+    typedef _VSTD::reverse_iterator<const_iterator>      const_reverse_iterator;
 
 private:
 
@@ -795,21 +800,24 @@
     _LIBCPP_TEMPLATE_DATA_VIS
     static const size_type npos = -1;
 
-    _LIBCPP_INLINE_VISIBILITY basic_string()
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 basic_string()
         _NOEXCEPT_(is_nothrow_default_constructible<allocator_type>::value);
 
-    _LIBCPP_INLINE_VISIBILITY explicit basic_string(const allocator_type& __a)
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
+    explicit basic_string(const allocator_type& __a)
 #if _LIBCPP_STD_VER <= 14
         _NOEXCEPT_(is_nothrow_copy_constructible<allocator_type>::value);
 #else
         _NOEXCEPT;
 #endif
 
+    _LIBCPP_CONSTEXPR_AFTER_CXX17
     basic_string(const basic_string& __str);
+    _LIBCPP_CONSTEXPR_AFTER_CXX17
     basic_string(const basic_string& __str, const allocator_type& __a);
 
 #ifndef _LIBCPP_CXX03_LANG
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     basic_string(basic_string&& __str)
 #if _LIBCPP_STD_VER <= 14
         _NOEXCEPT_(is_nothrow_move_constructible<allocator_type>::value);
@@ -817,12 +825,12 @@
         _NOEXCEPT;
 #endif
 
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     basic_string(basic_string&& __str, const allocator_type& __a);
 #endif // _LIBCPP_CXX03_LANG
 
     template <class = __enable_if_t<__is_allocator<_Allocator>::value, nullptr_t> >
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     basic_string(const _CharT* __s) : __r_(__default_init_tag(), __default_init_tag()) {
       _LIBCPP_ASSERT(__s != nullptr, "basic_string(const char*) detected nullptr");
       __init(__s, traits_type::length(__s));
@@ -832,80 +840,84 @@
     }
 
     template <class = __enable_if_t<__is_allocator<_Allocator>::value, nullptr_t> >
-        _LIBCPP_INLINE_VISIBILITY
+        _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
         basic_string(const _CharT* __s, const _Allocator& __a);
 
 #if _LIBCPP_STD_VER > 20
     basic_string(nullptr_t) = delete;
 #endif
 
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     basic_string(const _CharT* __s, size_type __n);
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     basic_string(const _CharT* __s, size_type __n, const _Allocator& __a);
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     basic_string(size_type __n, _CharT __c);
 
     template <class = __enable_if_t<__is_allocator<_Allocator>::value, nullptr_t> >
-        _LIBCPP_INLINE_VISIBILITY
+        _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
         basic_string(size_type __n, _CharT __c, const _Allocator& __a);
 
+    _LIBCPP_CONSTEXPR_AFTER_CXX17
     basic_string(const basic_string& __str, size_type __pos, size_type __n,
                  const _Allocator& __a = _Allocator());
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     basic_string(const basic_string& __str, size_type __pos,
                  const _Allocator& __a = _Allocator());
 
     template<class _Tp, class = __enable_if_t<__can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value && !__is_same_uncvref<_Tp, basic_string>::value> >
-        _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
+        _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS _LIBCPP_CONSTEXPR_AFTER_CXX17
         basic_string(const _Tp& __t, size_type __pos, size_type __n,
                      const allocator_type& __a = allocator_type());
 
     template<class _Tp, class = __enable_if_t<__can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value &&
                                           !__is_same_uncvref<_Tp, basic_string>::value> >
-        _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
+        _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS _LIBCPP_CONSTEXPR_AFTER_CXX17
         explicit basic_string(const _Tp& __t);
 
     template<class _Tp, class = __enable_if_t<__can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value && !__is_same_uncvref<_Tp, basic_string>::value> >
-        _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
+        _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS _LIBCPP_CONSTEXPR_AFTER_CXX17
         explicit basic_string(const _Tp& __t, const allocator_type& __a);
 
     template<class _InputIterator, class = __enable_if_t<__is_cpp17_input_iterator<_InputIterator>::value> >
-        _LIBCPP_INLINE_VISIBILITY
+        _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
         basic_string(_InputIterator __first, _InputIterator __last);
     template<class _InputIterator, class = __enable_if_t<__is_cpp17_input_iterator<_InputIterator>::value> >
-        _LIBCPP_INLINE_VISIBILITY
+        _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
         basic_string(_InputIterator __first, _InputIterator __last, const allocator_type& __a);
 #ifndef _LIBCPP_CXX03_LANG
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     basic_string(initializer_list<_CharT> __il);
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     basic_string(initializer_list<_CharT> __il, const _Allocator& __a);
 #endif // _LIBCPP_CXX03_LANG
 
-    inline ~basic_string();
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 inline ~basic_string();
 
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     operator __self_view() const _NOEXCEPT { return __self_view(data(), size()); }
 
+    _LIBCPP_CONSTEXPR_AFTER_CXX17
     basic_string& operator=(const basic_string& __str);
 
     template <class _Tp, class = __enable_if_t<__can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value && !__is_same_uncvref<_Tp, basic_string>::value> >
+    _LIBCPP_CONSTEXPR_AFTER_CXX17
     basic_string& operator=(const _Tp& __t)
         {__self_view __sv = __t; return assign(__sv);}
 
 #ifndef _LIBCPP_CXX03_LANG
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     basic_string& operator=(basic_string&& __str)
         _NOEXCEPT_((__noexcept_move_assign_container<_Allocator, __alloc_traits>::value));
-     _LIBCPP_INLINE_VISIBILITY
+     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     basic_string& operator=(initializer_list<value_type> __il) {return assign(__il.begin(), __il.size());}
 #endif
-    _LIBCPP_INLINE_VISIBILITY basic_string& operator=(const value_type* __s) {return assign(__s);}
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
+    basic_string& operator=(const value_type* __s) {return assign(__s);}
 #if _LIBCPP_STD_VER > 20
     basic_string& operator=(nullptr_t) = delete;
 #endif
-    basic_string& operator=(value_type __c);
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 basic_string& operator=(value_type __c);
 
 #if _LIBCPP_DEBUG_LEVEL == 2
     _LIBCPP_INLINE_VISIBILITY
@@ -921,106 +933,112 @@
     const_iterator end() const _NOEXCEPT
         {return const_iterator(this, __get_pointer() + size());}
 #else
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     iterator begin() _NOEXCEPT
         {return iterator(__get_pointer());}
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     const_iterator begin() const _NOEXCEPT
         {return const_iterator(__get_pointer());}
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     iterator end() _NOEXCEPT
         {return iterator(__get_pointer() + size());}
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     const_iterator end() const _NOEXCEPT
         {return const_iterator(__get_pointer() + size());}
 #endif // _LIBCPP_DEBUG_LEVEL == 2
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     reverse_iterator rbegin() _NOEXCEPT
         {return reverse_iterator(end());}
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     const_reverse_iterator rbegin() const _NOEXCEPT
         {return const_reverse_iterator(end());}
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     reverse_iterator rend() _NOEXCEPT
         {return reverse_iterator(begin());}
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     const_reverse_iterator rend() const _NOEXCEPT
         {return const_reverse_iterator(begin());}
 
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     const_iterator cbegin() const _NOEXCEPT
         {return begin();}
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     const_iterator cend() const _NOEXCEPT
         {return end();}
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     const_reverse_iterator crbegin() const _NOEXCEPT
         {return rbegin();}
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     const_reverse_iterator crend() const _NOEXCEPT
         {return rend();}
 
-    _LIBCPP_INLINE_VISIBILITY size_type size() const _NOEXCEPT
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 size_type size() const _NOEXCEPT
         {return __is_long() ? __get_long_size() : __get_short_size();}
-    _LIBCPP_INLINE_VISIBILITY size_type length() const _NOEXCEPT {return size();}
-    _LIBCPP_INLINE_VISIBILITY size_type max_size() const _NOEXCEPT;
-    _LIBCPP_INLINE_VISIBILITY size_type capacity() const _NOEXCEPT
-        {return (__is_long() ? __get_long_cap()
-                             : static_cast<size_type>(__min_cap)) - 1;}
 
-    void resize(size_type __n, value_type __c);
-    _LIBCPP_INLINE_VISIBILITY void resize(size_type __n) {resize(__n, value_type());}
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 size_type length() const _NOEXCEPT {return size();}
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 size_type max_size() const _NOEXCEPT;
+
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 size_type capacity() const _NOEXCEPT
+        {return (__is_long() ? __get_long_cap() : static_cast<size_type>(__min_cap)) - 1;}
+
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 void resize(size_type __n, value_type __c);
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 void resize(size_type __n) {resize(__n, value_type());}
 
-    void reserve(size_type __requested_capacity);
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 void reserve(size_type __requested_capacity);
     _LIBCPP_INLINE_VISIBILITY void __resize_default_init(size_type __n);
 
-    _LIBCPP_DEPRECATED_IN_CXX20 _LIBCPP_INLINE_VISIBILITY
-    void reserve() _NOEXCEPT {shrink_to_fit();}
-    _LIBCPP_INLINE_VISIBILITY
-    void shrink_to_fit() _NOEXCEPT;
-    _LIBCPP_INLINE_VISIBILITY
-    void clear() _NOEXCEPT;
-    _LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_DEPRECATED_IN_CXX20 _LIBCPP_INLINE_VISIBILITY void reserve() _NOEXCEPT {shrink_to_fit();}
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 void shrink_to_fit() _NOEXCEPT;
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 void clear() _NOEXCEPT;
+
+    _LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     bool empty() const _NOEXCEPT {return size() == 0;}
 
-    _LIBCPP_INLINE_VISIBILITY const_reference operator[](size_type __pos) const _NOEXCEPT;
-    _LIBCPP_INLINE_VISIBILITY reference       operator[](size_type __pos)       _NOEXCEPT;
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
+    const_reference operator[](size_type __pos) const _NOEXCEPT;
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
+    reference       operator[](size_type __pos)       _NOEXCEPT;
 
-    const_reference at(size_type __n) const;
-    reference       at(size_type __n);
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 const_reference at(size_type __n) const;
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 reference       at(size_type __n);
 
-    _LIBCPP_INLINE_VISIBILITY basic_string& operator+=(const basic_string& __str) {return append(__str);}
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
+    basic_string& operator+=(const basic_string& __str) {return append(__str);}
 
     template <class _Tp>
-    _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
+    _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS _LIBCPP_CONSTEXPR_AFTER_CXX17
     __enable_if_t
         <
             __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value
             && !__is_same_uncvref<_Tp, basic_string >::value,
             basic_string&
         >
-                                            operator+=(const _Tp& __t)            {__self_view __sv = __t; return append(__sv);}
-    _LIBCPP_INLINE_VISIBILITY basic_string& operator+=(const value_type* __s)     {return append(__s);}
-    _LIBCPP_INLINE_VISIBILITY basic_string& operator+=(value_type __c)            {push_back(__c); return *this;}
+        operator+=(const _Tp& __t) {__self_view __sv = __t; return append(__sv);}
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
+    basic_string& operator+=(const value_type* __s) {return append(__s);}
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
+    basic_string& operator+=(value_type __c) {push_back(__c); return *this;}
 #ifndef _LIBCPP_CXX03_LANG
-    _LIBCPP_INLINE_VISIBILITY basic_string& operator+=(initializer_list<value_type> __il) {return append(__il);}
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
+    basic_string& operator+=(initializer_list<value_type> __il) {return append(__il);}
 #endif // _LIBCPP_CXX03_LANG
 
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     basic_string& append(const basic_string& __str);
 
     template <class _Tp>
-    _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
+    _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS _LIBCPP_CONSTEXPR_AFTER_CXX17
     __enable_if_t<
             __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value
             && !__is_same_uncvref<_Tp, basic_string>::value,
             basic_string&
         >
                   append(const _Tp& __t) { __self_view __sv = __t; return append(__sv.data(), __sv.size()); }
+    _LIBCPP_CONSTEXPR_AFTER_CXX17
     basic_string& append(const basic_string& __str, size_type __pos, size_type __n=npos);
 
     template <class _Tp>
-    _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
+    _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS _LIBCPP_CONSTEXPR_AFTER_CXX17
     __enable_if_t
         <
             __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value
@@ -1028,9 +1046,9 @@
             basic_string&
         >
                   append(const _Tp& __t, size_type __pos, size_type __n=npos);
-    basic_string& append(const value_type* __s, size_type __n);
-    basic_string& append(const value_type* __s);
-    basic_string& append(size_type __n, value_type __c);
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 basic_string& append(const value_type* __s, size_type __n);
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 basic_string& append(const value_type* __s);
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 basic_string& append(size_type __n, value_type __c);
 
     _LIBCPP_INLINE_VISIBILITY
     void __append_default_init(size_type __n);
@@ -1042,7 +1060,7 @@
             __is_exactly_cpp17_input_iterator<_InputIterator>::value,
             basic_string&
         >
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     append(_InputIterator __first, _InputIterator __last) {
       const basic_string __temp(__first, __last, __alloc());
       append(__temp.data(), __temp.size());
@@ -1055,41 +1073,41 @@
             __is_cpp17_forward_iterator<_ForwardIterator>::value,
             basic_string&
         >
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     append(_ForwardIterator __first, _ForwardIterator __last);
 
 #ifndef _LIBCPP_CXX03_LANG
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     basic_string& append(initializer_list<value_type> __il) {return append(__il.begin(), __il.size());}
 #endif // _LIBCPP_CXX03_LANG
 
-    void push_back(value_type __c);
-    _LIBCPP_INLINE_VISIBILITY
-    void pop_back();
-    _LIBCPP_INLINE_VISIBILITY reference       front() _NOEXCEPT;
-    _LIBCPP_INLINE_VISIBILITY const_reference front() const _NOEXCEPT;
-    _LIBCPP_INLINE_VISIBILITY reference       back() _NOEXCEPT;
-    _LIBCPP_INLINE_VISIBILITY const_reference back() const _NOEXCEPT;
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 void push_back(value_type __c);
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 void pop_back();
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 reference front() _NOEXCEPT;
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 const_reference front() const _NOEXCEPT;
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 reference back() _NOEXCEPT;
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 const_reference back() const _NOEXCEPT;
 
     template <class _Tp>
-    _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
+    _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS _LIBCPP_CONSTEXPR_AFTER_CXX17
     __enable_if_t
         <
             __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value,
             basic_string&
         >
                  assign(const _Tp & __t) { __self_view __sv = __t; return assign(__sv.data(), __sv.size()); }
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     basic_string& assign(const basic_string& __str) { return *this = __str; }
 #ifndef _LIBCPP_CXX03_LANG
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     basic_string& assign(basic_string&& __str)
         _NOEXCEPT_((__noexcept_move_assign_container<_Allocator, __alloc_traits>::value))
         {*this = _VSTD::move(__str); return *this;}
 #endif
+    _LIBCPP_CONSTEXPR_AFTER_CXX17
     basic_string& assign(const basic_string& __str, size_type __pos, size_type __n=npos);
     template <class _Tp>
-    _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
+    _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS _LIBCPP_CONSTEXPR_AFTER_CXX17
     __enable_if_t
         <
             __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value
@@ -1097,11 +1115,14 @@
             basic_string&
         >
                   assign(const _Tp & __t, size_type __pos, size_type __n=npos);
+    _LIBCPP_CONSTEXPR_AFTER_CXX17
     basic_string& assign(const value_type* __s, size_type __n);
+    _LIBCPP_CONSTEXPR_AFTER_CXX17
     basic_string& assign(const value_type* __s);
+    _LIBCPP_CONSTEXPR_AFTER_CXX17
     basic_string& assign(size_type __n, value_type __c);
     template<class _InputIterator>
-    _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
+    _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS _LIBCPP_CONSTEXPR_AFTER_CXX17
     __enable_if_t
         <
             __is_exactly_cpp17_input_iterator<_InputIterator>::value,
@@ -1109,7 +1130,7 @@
         >
         assign(_InputIterator __first, _InputIterator __last);
     template<class _ForwardIterator>
-    _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
+    _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS _LIBCPP_CONSTEXPR_AFTER_CXX17
     __enable_if_t
         <
             __is_cpp17_forward_iterator<_ForwardIterator>::value,
@@ -1117,15 +1138,15 @@
         >
         assign(_ForwardIterator __first, _ForwardIterator __last);
 #ifndef _LIBCPP_CXX03_LANG
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     basic_string& assign(initializer_list<value_type> __il) {return assign(__il.begin(), __il.size());}
 #endif // _LIBCPP_CXX03_LANG
 
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     basic_string& insert(size_type __pos1, const basic_string& __str);
 
     template <class _Tp>
-    _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
+    _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS _LIBCPP_CONSTEXPR_AFTER_CXX17
     __enable_if_t
         <
             __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value,
@@ -1135,22 +1156,23 @@
     { __self_view __sv = __t; return insert(__pos1, __sv.data(), __sv.size()); }
 
     template <class _Tp>
-    _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
+    _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS _LIBCPP_CONSTEXPR_AFTER_CXX17
     __enable_if_t
         <
             __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value && !__is_same_uncvref<_Tp, basic_string>::value,
             basic_string&
         >
                   insert(size_type __pos1, const _Tp& __t, size_type __pos2, size_type __n=npos);
+    _LIBCPP_CONSTEXPR_AFTER_CXX17
     basic_string& insert(size_type __pos1, const basic_string& __str, size_type __pos2, size_type __n=npos);
-    basic_string& insert(size_type __pos, const value_type* __s, size_type __n);
-    basic_string& insert(size_type __pos, const value_type* __s);
-    basic_string& insert(size_type __pos, size_type __n, value_type __c);
-    iterator      insert(const_iterator __pos, value_type __c);
-    _LIBCPP_INLINE_VISIBILITY
-    iterator      insert(const_iterator __pos, size_type __n, value_type __c);
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 basic_string& insert(size_type __pos, const value_type* __s, size_type __n);
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 basic_string& insert(size_type __pos, const value_type* __s);
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 basic_string& insert(size_type __pos, size_type __n, value_type __c);
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 iterator      insert(const_iterator __pos, value_type __c);
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
+    iterator insert(const_iterator __pos, size_type __n, value_type __c);
     template<class _InputIterator>
-    _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
+    _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS _LIBCPP_CONSTEXPR_AFTER_CXX17
     __enable_if_t
         <
             __is_exactly_cpp17_input_iterator<_InputIterator>::value,
@@ -1158,7 +1180,7 @@
         >
         insert(const_iterator __pos, _InputIterator __first, _InputIterator __last);
     template<class _ForwardIterator>
-    _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
+    _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS _LIBCPP_CONSTEXPR_AFTER_CXX17
     __enable_if_t
         <
             __is_cpp17_forward_iterator<_ForwardIterator>::value,
@@ -1166,45 +1188,49 @@
         >
         insert(const_iterator __pos, _ForwardIterator __first, _ForwardIterator __last);
 #ifndef _LIBCPP_CXX03_LANG
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     iterator insert(const_iterator __pos, initializer_list<value_type> __il)
                     {return insert(__pos, __il.begin(), __il.end());}
 #endif // _LIBCPP_CXX03_LANG
 
-    basic_string& erase(size_type __pos = 0, size_type __n = npos);
-    _LIBCPP_INLINE_VISIBILITY
-    iterator      erase(const_iterator __pos);
-    _LIBCPP_INLINE_VISIBILITY
-    iterator      erase(const_iterator __first, const_iterator __last);
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 basic_string& erase(size_type __pos = 0, size_type __n = npos);
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 iterator erase(const_iterator __pos);
+    
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
+    iterator erase(const_iterator __first, const_iterator __last);
 
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     basic_string& replace(size_type __pos1, size_type __n1, const basic_string& __str);
 
     template <class _Tp>
-    _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
+    _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS _LIBCPP_CONSTEXPR_AFTER_CXX17
     __enable_if_t
         <
             __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value,
             basic_string&
         >
                   replace(size_type __pos1, size_type __n1, const _Tp& __t) { __self_view __sv = __t; return replace(__pos1, __n1, __sv.data(), __sv.size()); }
+    _LIBCPP_CONSTEXPR_AFTER_CXX17
     basic_string& replace(size_type __pos1, size_type __n1, const basic_string& __str, size_type __pos2, size_type __n2=npos);
     template <class _Tp>
-    _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
+    _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS _LIBCPP_CONSTEXPR_AFTER_CXX17
     __enable_if_t
         <
             __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value  && !__is_same_uncvref<_Tp, basic_string>::value,
             basic_string&
         >
                   replace(size_type __pos1, size_type __n1, const _Tp& __t, size_type __pos2, size_type __n2=npos);
+    _LIBCPP_CONSTEXPR_AFTER_CXX17
     basic_string& replace(size_type __pos, size_type __n1, const value_type* __s, size_type __n2);
+    _LIBCPP_CONSTEXPR_AFTER_CXX17
     basic_string& replace(size_type __pos, size_type __n1, const value_type* __s);
+    _LIBCPP_CONSTEXPR_AFTER_CXX17
     basic_string& replace(size_type __pos, size_type __n1, size_type __n2, value_type __c);
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     basic_string& replace(const_iterator __i1, const_iterator __i2, const basic_string& __str);
 
     template <class _Tp>
-    _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
+    _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS _LIBCPP_CONSTEXPR_AFTER_CXX17
     __enable_if_t
         <
             __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value,
@@ -1212,14 +1238,14 @@
         >
                   replace(const_iterator __i1, const_iterator __i2, const _Tp& __t) { __self_view __sv = __t; return replace(__i1 - begin(), __i2 - __i1, __sv); }
 
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     basic_string& replace(const_iterator __i1, const_iterator __i2, const value_type* __s, size_type __n);
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     basic_string& replace(const_iterator __i1, const_iterator __i2, const value_type* __s);
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     basic_string& replace(const_iterator __i1, const_iterator __i2, size_type __n, value_type __c);
     template<class _InputIterator>
-    _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
+    _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS _LIBCPP_CONSTEXPR_AFTER_CXX17
     __enable_if_t
         <
             __is_cpp17_input_iterator<_InputIterator>::value,
@@ -1227,17 +1253,16 @@
         >
         replace(const_iterator __i1, const_iterator __i2, _InputIterator __j1, _InputIterator __j2);
 #ifndef _LIBCPP_CXX03_LANG
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     basic_string& replace(const_iterator __i1, const_iterator __i2, initializer_list<value_type> __il)
         {return replace(__i1, __i2, __il.begin(), __il.end());}
 #endif // _LIBCPP_CXX03_LANG
 
-    size_type copy(value_type* __s, size_type __n, size_type __pos = 0) const;
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 size_type copy(value_type* __s, size_type __n, size_type __pos = 0) const;
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     basic_string substr(size_type __pos = 0, size_type __n = npos) const;
 
-    _LIBCPP_INLINE_VISIBILITY
-    void swap(basic_string& __str)
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 void swap(basic_string& __str)
 #if _LIBCPP_STD_VER >= 14
         _NOEXCEPT;
 #else
@@ -1245,123 +1270,131 @@
                     __is_nothrow_swappable<allocator_type>::value);
 #endif
 
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     const value_type* c_str() const _NOEXCEPT {return data();}
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     const value_type* data() const _NOEXCEPT  {return _VSTD::__to_address(__get_pointer());}
 #if _LIBCPP_STD_VER > 14 || defined(_LIBCPP_BUILDING_LIBRARY)
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     value_type* data()             _NOEXCEPT  {return _VSTD::__to_address(__get_pointer());}
 #endif
 
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     allocator_type get_allocator() const _NOEXCEPT {return __alloc();}
 
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     size_type find(const basic_string& __str, size_type __pos = 0) const _NOEXCEPT;
 
     template <class _Tp>
-    _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
+    _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS _LIBCPP_CONSTEXPR_AFTER_CXX17
     __enable_if_t
         <
             __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value,
             size_type
         >
               find(const _Tp& __t, size_type __pos = 0) const _NOEXCEPT;
+    _LIBCPP_CONSTEXPR_AFTER_CXX17
     size_type find(const value_type* __s, size_type __pos, size_type __n) const _NOEXCEPT;
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     size_type find(const value_type* __s, size_type __pos = 0) const _NOEXCEPT;
+    _LIBCPP_CONSTEXPR_AFTER_CXX17
     size_type find(value_type __c, size_type __pos = 0) const _NOEXCEPT;
 
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     size_type rfind(const basic_string& __str, size_type __pos = npos) const _NOEXCEPT;
 
     template <class _Tp>
-    _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
+    _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS _LIBCPP_CONSTEXPR_AFTER_CXX17
     __enable_if_t
         <
             __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value,
             size_type
         >
               rfind(const _Tp& __t, size_type __pos = npos) const _NOEXCEPT;
+    _LIBCPP_CONSTEXPR_AFTER_CXX17
     size_type rfind(const value_type* __s, size_type __pos, size_type __n) const _NOEXCEPT;
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     size_type rfind(const value_type* __s, size_type __pos = npos) const _NOEXCEPT;
+    _LIBCPP_CONSTEXPR_AFTER_CXX17
     size_type rfind(value_type __c, size_type __pos = npos) const _NOEXCEPT;
 
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     size_type find_first_of(const basic_string& __str, size_type __pos = 0) const _NOEXCEPT;
 
     template <class _Tp>
-    _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
+    _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS _LIBCPP_CONSTEXPR_AFTER_CXX17
     __enable_if_t
         <
             __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value,
             size_type
         >
               find_first_of(const _Tp& __t, size_type __pos = 0) const _NOEXCEPT;
+    _LIBCPP_CONSTEXPR_AFTER_CXX17
     size_type find_first_of(const value_type* __s, size_type __pos, size_type __n) const _NOEXCEPT;
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     size_type find_first_of(const value_type* __s, size_type __pos = 0) const _NOEXCEPT;
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     size_type find_first_of(value_type __c, size_type __pos = 0) const _NOEXCEPT;
 
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     size_type find_last_of(const basic_string& __str, size_type __pos = npos) const _NOEXCEPT;
 
     template <class _Tp>
-    _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
+    _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS _LIBCPP_CONSTEXPR_AFTER_CXX17
     __enable_if_t
         <
             __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value,
             size_type
         >
               find_last_of(const _Tp& __t, size_type __pos = npos) const _NOEXCEPT;
+              _LIBCPP_CONSTEXPR_AFTER_CXX17
     size_type find_last_of(const value_type* __s, size_type __pos, size_type __n) const _NOEXCEPT;
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     size_type find_last_of(const value_type* __s, size_type __pos = npos) const _NOEXCEPT;
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     size_type find_last_of(value_type __c, size_type __pos = npos) const _NOEXCEPT;
 
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     size_type find_first_not_of(const basic_string& __str, size_type __pos = 0) const _NOEXCEPT;
 
     template <class _Tp>
-    _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
+    _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS _LIBCPP_CONSTEXPR_AFTER_CXX17
     __enable_if_t
         <
             __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value,
             size_type
         >
               find_first_not_of(const _Tp &__t, size_type __pos = 0) const _NOEXCEPT;
+    _LIBCPP_CONSTEXPR_AFTER_CXX17
     size_type find_first_not_of(const value_type* __s, size_type __pos, size_type __n) const _NOEXCEPT;
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     size_type find_first_not_of(const value_type* __s, size_type __pos = 0) const _NOEXCEPT;
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     size_type find_first_not_of(value_type __c, size_type __pos = 0) const _NOEXCEPT;
 
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     size_type find_last_not_of(const basic_string& __str, size_type __pos = npos) const _NOEXCEPT;
 
     template <class _Tp>
-    _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
+    _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS _LIBCPP_CONSTEXPR_AFTER_CXX17
     __enable_if_t
         <
             __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value,
             size_type
         >
               find_last_not_of(const _Tp& __t, size_type __pos = npos) const _NOEXCEPT;
+    _LIBCPP_CONSTEXPR_AFTER_CXX17
     size_type find_last_not_of(const value_type* __s, size_type __pos, size_type __n) const _NOEXCEPT;
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     size_type find_last_not_of(const value_type* __s, size_type __pos = npos) const _NOEXCEPT;
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     size_type find_last_not_of(value_type __c, size_type __pos = npos) const _NOEXCEPT;
 
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     int compare(const basic_string& __str) const _NOEXCEPT;
 
     template <class _Tp>
-    _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
+    _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS _LIBCPP_CONSTEXPR_AFTER_CXX17
     __enable_if_t
         <
             __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value,
@@ -1370,7 +1403,7 @@
         compare(const _Tp &__t) const _NOEXCEPT;
 
     template <class _Tp>
-    _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
+    _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS _LIBCPP_CONSTEXPR_AFTER_CXX17
     __enable_if_t
         <
             __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value,
@@ -1378,20 +1411,22 @@
         >
          compare(size_type __pos1, size_type __n1, const _Tp& __t) const;
 
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     int compare(size_type __pos1, size_type __n1, const basic_string& __str) const;
+    _LIBCPP_CONSTEXPR_AFTER_CXX17
     int compare(size_type __pos1, size_type __n1, const basic_string& __str, size_type __pos2, size_type __n2=npos) const;
 
     template <class _Tp>
-    inline _LIBCPP_INLINE_VISIBILITY
+    inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
         __enable_if_t
         <
             __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value  && !__is_same_uncvref<_Tp, basic_string>::value,
             int
         >
         compare(size_type __pos1, size_type __n1, const _Tp& __t, size_type __pos2, size_type __n2=npos) const;
-    int compare(const value_type* __s) const _NOEXCEPT;
-    int compare(size_type __pos1, size_type __n1, const value_type* __s) const;
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 int compare(const value_type* __s) const _NOEXCEPT;
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 int compare(size_type __pos1, size_type __n1, const value_type* __s) const;
+    _LIBCPP_CONSTEXPR_AFTER_CXX17
     int compare(size_type __pos1, size_type __n1, const value_type* __s, size_type __n2) const;
 
 #if _LIBCPP_STD_VER > 17
@@ -1434,15 +1469,17 @@
     { return __self_view(data(), size()).contains(__s); }
 #endif
 
-    _LIBCPP_INLINE_VISIBILITY bool __invariants() const;
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 bool __invariants() const;
 
-    _LIBCPP_INLINE_VISIBILITY void __clear_and_shrink() _NOEXCEPT;
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 void __clear_and_shrink() _NOEXCEPT;
 
-    _LIBCPP_INLINE_VISIBILITY void __shrink_or_extend(size_type __target_capacity);
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 void __shrink_or_extend(size_type __target_capacity);
 
-    _LIBCPP_INLINE_VISIBILITY
-    bool __is_long() const _NOEXCEPT
-        {return bool(__r_.first().__s.__size_ & __short_mask);}
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 bool __is_long() const _NOEXCEPT { 
+      if (__libcpp_is_constant_evaluated())
+        return true;
+      return bool(__r_.first().__s.__size_ & __short_mask);
+    }
 
 #if _LIBCPP_DEBUG_LEVEL == 2
 
@@ -1454,10 +1491,10 @@
 #endif // _LIBCPP_DEBUG_LEVEL == 2
 
 private:
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     allocator_type& __alloc() _NOEXCEPT
         {return __r_.second();}
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     const allocator_type& __alloc() const _NOEXCEPT
         {return __r_.second();}
 
@@ -1499,30 +1536,30 @@
 
 #endif // _LIBCPP_ABI_ALTERNATE_STRING_LAYOUT
 
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     void __set_long_size(size_type __s) _NOEXCEPT
         {__r_.first().__l.__size_ = __s;}
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     size_type __get_long_size() const _NOEXCEPT
         {return __r_.first().__l.__size_;}
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     void __set_size(size_type __s) _NOEXCEPT
         {if (__is_long()) __set_long_size(__s); else __set_short_size(__s);}
 
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     void __set_long_cap(size_type __s) _NOEXCEPT
         {__r_.first().__l.__cap_  = __long_mask | __s;}
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     size_type __get_long_cap() const _NOEXCEPT
         {return __r_.first().__l.__cap_ & size_type(~__long_mask);}
 
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     void __set_long_pointer(pointer __p) _NOEXCEPT
         {__r_.first().__l.__data_ = __p;}
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     pointer __get_long_pointer() _NOEXCEPT
         {return __r_.first().__l.__data_;}
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     const_pointer __get_long_pointer() const _NOEXCEPT
         {return __r_.first().__l.__data_;}
     _LIBCPP_INLINE_VISIBILITY
@@ -1531,41 +1568,46 @@
     _LIBCPP_INLINE_VISIBILITY
     const_pointer __get_short_pointer() const _NOEXCEPT
         {return pointer_traits<const_pointer>::pointer_to(__r_.first().__s.__data_[0]);}
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     pointer __get_pointer() _NOEXCEPT
         {return __is_long() ? __get_long_pointer() : __get_short_pointer();}
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     const_pointer __get_pointer() const _NOEXCEPT
         {return __is_long() ? __get_long_pointer() : __get_short_pointer();}
 
-    _LIBCPP_INLINE_VISIBILITY
-    void __zero() _NOEXCEPT
-        {
-            size_type (&__a)[__n_words] = __r_.first().__r.__words;
-            for (unsigned __i = 0; __i < __n_words; ++__i)
-                __a[__i] = 0;
-        }
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
+    void __zero() _NOEXCEPT {
+      size_type (&__a)[__n_words] = __r_.first().__r.__words;
+      if (__libcpp_is_constant_evaluated()) {
+        __r_.first() = __rep();
+        return;
+      }
+      for (unsigned __i = 0; __i < __n_words; ++__i)
+        __a[__i] = 0;
+    }
 
     template <size_type __a> static
-        _LIBCPP_INLINE_VISIBILITY
+        _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
         size_type __align_it(size_type __s) _NOEXCEPT
             {return (__s + (__a-1)) & ~(__a-1);}
     enum {__alignment = 16};
-    static _LIBCPP_INLINE_VISIBILITY
+    static _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     size_type __recommend(size_type __s) _NOEXCEPT
-        {
+    {
+        if (__libcpp_is_constant_evaluated())
+            return __s + 1;
         if (__s < __min_cap) return static_cast<size_type>(__min_cap) - 1;
         size_type __guess = __align_it<sizeof(value_type) < __alignment ?
                      __alignment/sizeof(value_type) : 1 > (__s+1) - 1;
         if (__guess == __min_cap) ++__guess;
         return __guess;
-        }
+    }
 
-    inline
+    inline _LIBCPP_CONSTEXPR_AFTER_CXX17
     void __init(const value_type* __s, size_type __sz, size_type __reserve);
-    inline
+    inline _LIBCPP_CONSTEXPR_AFTER_CXX17
     void __init(const value_type* __s, size_type __sz);
-    inline
+    inline _LIBCPP_CONSTEXPR_AFTER_CXX17
     void __init(size_type __n, value_type __c);
 
     // Slow path for the (inlined) copy constructor for 'long' strings.
@@ -1576,10 +1618,11 @@
     // to call the __init() functions as those are marked as inline which may
     // result in over-aggressive inlining by the compiler, where our aim is
     // to only inline the fast path code directly in the ctor.
+    _LIBCPP_CONSTEXPR_AFTER_CXX17
     void __init_copy_ctor_external(const value_type* __s, size_type __sz);
 
     template <class _InputIterator>
-    inline
+    inline _LIBCPP_CONSTEXPR_AFTER_CXX17
     __enable_if_t
     <
         __is_exactly_cpp17_input_iterator<_InputIterator>::value
@@ -1587,15 +1630,20 @@
     __init(_InputIterator __first, _InputIterator __last);
 
     template <class _ForwardIterator>
-    inline
+    inline _LIBCPP_CONSTEXPR_AFTER_CXX17
     __enable_if_t
     <
         __is_cpp17_forward_iterator<_ForwardIterator>::value
     >
     __init(_ForwardIterator __first, _ForwardIterator __last);
 
+    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17
+    void __free_memory_constexpr();
+
+    _LIBCPP_CONSTEXPR_AFTER_CXX17
     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);
+    _LIBCPP_CONSTEXPR_AFTER_CXX17
     void __grow_by_and_replace(size_type __old_cap, size_type __delta_cap, size_type __old_sz,
                                size_type __n_copy,  size_type __n_del,
                                size_type __n_add, const value_type* __p_new_stuff);
@@ -1604,21 +1652,25 @@
     // have proof that the input does not alias the current instance.
     // For example, operator=(basic_string) performs a 'self' check.
     template <bool __is_short>
+    _LIBCPP_CONSTEXPR_AFTER_CXX17
     basic_string& __assign_no_alias(const value_type* __s, size_type __n);
 
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     void __erase_to_end(size_type __pos);
 
+    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17
+    void __finish_replace(size_type& __sz, size_type& __n1, size_type& __n2, value_type*& __p);
+
     // __erase_external_with_move is invoked for erase() invocations where
     // `n ~= npos`, likely requiring memory moves on the string data.
-    void __erase_external_with_move(size_type __pos, size_type __n);
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 void __erase_external_with_move(size_type __pos, size_type __n);
 
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     void __copy_assign_alloc(const basic_string& __str)
         {__copy_assign_alloc(__str, integral_constant<bool,
                       __alloc_traits::propagate_on_container_copy_assignment::value>());}
 
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     void __copy_assign_alloc(const basic_string& __str, true_type)
         {
             if (__alloc() == __str.__alloc())
@@ -1634,6 +1686,7 @@
                 {
                     allocator_type __a = __str.__alloc();
                     pointer __p = __alloc_traits::allocate(__a, __str.__get_long_cap());
+                    __begin_lifetime(__p, __str.__get_long_cap());
                     __clear_and_shrink();
                     __alloc() = _VSTD::move(__a);
                     __set_long_pointer(__p);
@@ -1643,15 +1696,15 @@
             }
         }
 
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     void __copy_assign_alloc(const basic_string&, false_type) _NOEXCEPT
         {}
 
 #ifndef _LIBCPP_CXX03_LANG
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     void __move_assign(basic_string& __str, false_type)
         _NOEXCEPT_(__alloc_traits::is_always_equal::value);
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     void __move_assign(basic_string& __str, true_type)
 #if _LIBCPP_STD_VER > 14
         _NOEXCEPT;
@@ -1660,7 +1713,7 @@
 #endif
 #endif
 
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     void
     __move_assign_alloc(basic_string& __str)
         _NOEXCEPT_(
@@ -1669,19 +1722,20 @@
     {__move_assign_alloc(__str, integral_constant<bool,
                       __alloc_traits::propagate_on_container_move_assignment::value>());}
 
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     void __move_assign_alloc(basic_string& __c, true_type)
         _NOEXCEPT_(is_nothrow_move_assignable<allocator_type>::value)
         {
             __alloc() = _VSTD::move(__c.__alloc());
         }
 
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     void __move_assign_alloc(basic_string&, false_type)
         _NOEXCEPT
         {}
 
     basic_string& __assign_external(const value_type* __s);
+    _LIBCPP_CONSTEXPR_AFTER_CXX17
     basic_string& __assign_external(const value_type* __s, size_type __n);
 
     // Assigns the value in __s, guaranteed to be __n < __min_cap in length.
@@ -1694,8 +1748,10 @@
       return *this;
     }
 
-    _LIBCPP_INLINE_VISIBILITY void __invalidate_all_iterators();
-    _LIBCPP_INLINE_VISIBILITY void __invalidate_iterators_past(size_type);
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
+    void __invalidate_all_iterators();
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
+    void __invalidate_iterators_past(size_type);
 
     template<class _Tp>
     _LIBCPP_INLINE_VISIBILITY
@@ -1713,7 +1769,7 @@
 #endif
     }
 
-    _LIBCPP_NORETURN _LIBCPP_HIDE_FROM_ABI
+    _LIBCPP_NORETURN _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17
     void __throw_out_of_range() const {
 #ifndef _LIBCPP_NO_EXCEPTIONS
         __basic_string_common<true>::__throw_out_of_range();
@@ -1722,11 +1778,29 @@
 #endif
     }
 
-    friend basic_string operator+<>(const basic_string&, const basic_string&);
-    friend basic_string operator+<>(const value_type*, const basic_string&);
-    friend basic_string operator+<>(value_type, const basic_string&);
-    friend basic_string operator+<>(const basic_string&, const value_type*);
-    friend basic_string operator+<>(const basic_string&, value_type);
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX11 void __begin_lifetime(pointer __p, size_type __count) {
+#if _LIBCPP_STD_VER > 17
+    if (__libcpp_is_constant_evaluated()) {
+      for (size_type __i = 0; __i < __count; ++__i)
+        construct_at(&__p[__i], value_type());
+    }
+#else
+    ((void)__p);
+    ((void)__count);
+#endif
+  }
+
+    template<class _ForwardIterator>
+    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX11 void __insert_not_in_range(size_type __ip,
+                                                                                   size_type __n,
+                                                                                   _ForwardIterator __first,
+                                                                                   _ForwardIterator __last);
+
+    friend _LIBCPP_CONSTEXPR_AFTER_CXX17 basic_string operator+<>(const basic_string&, const basic_string&);
+    friend _LIBCPP_CONSTEXPR_AFTER_CXX17 basic_string operator+<>(const value_type*, const basic_string&);
+    friend _LIBCPP_CONSTEXPR_AFTER_CXX17 basic_string operator+<>(value_type, const basic_string&);
+    friend _LIBCPP_CONSTEXPR_AFTER_CXX17 basic_string operator+<>(const basic_string&, const value_type*);
+    friend _LIBCPP_CONSTEXPR_AFTER_CXX17 basic_string operator+<>(const basic_string&, value_type);
 };
 
 // These declarations must appear before any functions are implicitly used
@@ -1773,7 +1847,7 @@
 #endif
 
 template <class _CharT, class _Traits, class _Allocator>
-inline
+inline _LIBCPP_CONSTEXPR_AFTER_CXX17
 void
 basic_string<_CharT, _Traits, _Allocator>::__invalidate_all_iterators()
 {
@@ -1783,7 +1857,7 @@
 }
 
 template <class _CharT, class _Traits, class _Allocator>
-inline
+inline _LIBCPP_CONSTEXPR_AFTER_CXX17
 void
 basic_string<_CharT, _Traits, _Allocator>::__invalidate_iterators_past(size_type __pos)
 {
@@ -1811,7 +1885,7 @@
 }
 
 template <class _CharT, class _Traits, class _Allocator>
-inline
+inline _LIBCPP_CONSTEXPR_AFTER_CXX17
 basic_string<_CharT, _Traits, _Allocator>::basic_string()
     _NOEXCEPT_(is_nothrow_default_constructible<allocator_type>::value)
      : __r_(__default_init_tag(), __default_init_tag())
@@ -1819,11 +1893,14 @@
 #if _LIBCPP_DEBUG_LEVEL == 2
     __get_db()->__insert_c(this);
 #endif
+  if (__libcpp_is_constant_evaluated())
+    __init(size_type(), value_type());
+  else
     __zero();
 }
 
 template <class _CharT, class _Traits, class _Allocator>
-inline
+inline _LIBCPP_CONSTEXPR_AFTER_CXX17
 basic_string<_CharT, _Traits, _Allocator>::basic_string(const allocator_type& __a)
 #if _LIBCPP_STD_VER <= 14
         _NOEXCEPT_(is_nothrow_copy_constructible<allocator_type>::value)
@@ -1835,18 +1912,24 @@
 #if _LIBCPP_DEBUG_LEVEL == 2
     __get_db()->__insert_c(this);
 #endif
+  if (__libcpp_is_constant_evaluated())
+    __init(size_type(0), value_type());
+  else
     __zero();
 }
 
 template <class _CharT, class _Traits, class _Allocator>
+_LIBCPP_CONSTEXPR_AFTER_CXX17
 void basic_string<_CharT, _Traits, _Allocator>::__init(const value_type* __s,
                                                        size_type __sz,
                                                        size_type __reserve)
 {
+    if (__libcpp_is_constant_evaluated())
+        __zero();
     if (__reserve > max_size())
         this->__throw_length_error();
     pointer __p;
-    if (__reserve < __min_cap)
+    if (__reserve < __min_cap && !__libcpp_is_constant_evaluated())
     {
         __set_short_size(__sz);
         __p = __get_short_pointer();
@@ -1855,6 +1938,7 @@
     {
         size_type __cap = __recommend(__reserve);
         __p = __alloc_traits::allocate(__alloc(), __cap+1);
+        __begin_lifetime(__p, __cap + 1);
         __set_long_pointer(__p);
         __set_long_cap(__cap+1);
         __set_long_size(__sz);
@@ -1864,31 +1948,16 @@
 }
 
 template <class _CharT, class _Traits, class _Allocator>
+_LIBCPP_CONSTEXPR_AFTER_CXX17
 void
 basic_string<_CharT, _Traits, _Allocator>::__init(const value_type* __s, size_type __sz)
 {
-    if (__sz > max_size())
-        this->__throw_length_error();
-    pointer __p;
-    if (__sz < __min_cap)
-    {
-        __set_short_size(__sz);
-        __p = __get_short_pointer();
-    }
-    else
-    {
-        size_type __cap = __recommend(__sz);
-        __p = __alloc_traits::allocate(__alloc(), __cap+1);
-        __set_long_pointer(__p);
-        __set_long_cap(__cap+1);
-        __set_long_size(__sz);
-    }
-    traits_type::copy(_VSTD::__to_address(__p), __s, __sz);
-    traits_type::assign(__p[__sz], value_type());
+    __init(__s, __sz, __sz);
 }
 
 template <class _CharT, class _Traits, class _Allocator>
 template <class>
+_LIBCPP_CONSTEXPR_AFTER_CXX17
 basic_string<_CharT, _Traits, _Allocator>::basic_string(const _CharT* __s, const _Allocator& __a)
     : __r_(__default_init_tag(), __a)
 {
@@ -1900,7 +1969,7 @@
 }
 
 template <class _CharT, class _Traits, class _Allocator>
-inline
+inline _LIBCPP_CONSTEXPR_AFTER_CXX17
 basic_string<_CharT, _Traits, _Allocator>::basic_string(const _CharT* __s, size_type __n)
      : __r_(__default_init_tag(), __default_init_tag())
 {
@@ -1912,7 +1981,7 @@
 }
 
 template <class _CharT, class _Traits, class _Allocator>
-inline
+inline _LIBCPP_CONSTEXPR_AFTER_CXX17
 basic_string<_CharT, _Traits, _Allocator>::basic_string(const _CharT* __s, size_type __n, const _Allocator& __a)
     : __r_(__default_init_tag(), __a)
 {
@@ -1924,6 +1993,7 @@
 }
 
 template <class _CharT, class _Traits, class _Allocator>
+_LIBCPP_CONSTEXPR_AFTER_CXX17
 basic_string<_CharT, _Traits, _Allocator>::basic_string(const basic_string& __str)
     : __r_(__default_init_tag(), __alloc_traits::select_on_container_copy_construction(__str.__alloc()))
 {
@@ -1939,6 +2009,7 @@
 }
 
 template <class _CharT, class _Traits, class _Allocator>
+_LIBCPP_CONSTEXPR_AFTER_CXX17
 basic_string<_CharT, _Traits, _Allocator>::basic_string(
     const basic_string& __str, const allocator_type& __a)
     : __r_(__default_init_tag(), __a)
@@ -1954,10 +2025,13 @@
 }
 
 template <class _CharT, class _Traits, class _Allocator>
+_LIBCPP_CONSTEXPR_AFTER_CXX17
 void basic_string<_CharT, _Traits, _Allocator>::__init_copy_ctor_external(
     const value_type* __s, size_type __sz) {
+  if (__libcpp_is_constant_evaluated())
+    __zero();
   pointer __p;
-  if (__sz < __min_cap) {
+  if (__sz < __min_cap && !__libcpp_is_constant_evaluated()) {
     __p = __get_short_pointer();
     __set_short_size(__sz);
   } else {
@@ -1965,6 +2039,7 @@
       this->__throw_length_error();
     size_t __cap = __recommend(__sz);
     __p = __alloc_traits::allocate(__alloc(), __cap + 1);
+    __begin_lifetime(__p, __cap + 1);
     __set_long_pointer(__p);
     __set_long_cap(__cap + 1);
     __set_long_size(__sz);
@@ -1975,7 +2050,7 @@
 #ifndef _LIBCPP_CXX03_LANG
 
 template <class _CharT, class _Traits, class _Allocator>
-inline
+inline _LIBCPP_CONSTEXPR_AFTER_CXX17
 basic_string<_CharT, _Traits, _Allocator>::basic_string(basic_string&& __str)
 #if _LIBCPP_STD_VER <= 14
         _NOEXCEPT_(is_nothrow_move_constructible<allocator_type>::value)
@@ -1993,7 +2068,7 @@
 }
 
 template <class _CharT, class _Traits, class _Allocator>
-inline
+inline _LIBCPP_CONSTEXPR_AFTER_CXX17
 basic_string<_CharT, _Traits, _Allocator>::basic_string(basic_string&& __str, const allocator_type& __a)
     : __r_(__default_init_tag(), __a)
 {
@@ -2001,7 +2076,13 @@
         __init(_VSTD::__to_address(__str.__get_long_pointer()), __str.__get_long_size());
     else
     {
-        __r_.first().__r = __str.__r_.first().__r;
+        if (__libcpp_is_constant_evaluated())
+        {
+            __r_.first() = __rep();
+            __r_.first().__l = __str.__r_.first().__l;
+        }
+        else
+            __r_.first().__r = __str.__r_.first().__r;
         __str.__zero();
     }
 #if _LIBCPP_DEBUG_LEVEL == 2
@@ -2014,13 +2095,16 @@
 #endif // _LIBCPP_CXX03_LANG
 
 template <class _CharT, class _Traits, class _Allocator>
+_LIBCPP_CONSTEXPR_AFTER_CXX17
 void
 basic_string<_CharT, _Traits, _Allocator>::__init(size_type __n, value_type __c)
 {
+    if (__libcpp_is_constant_evaluated())
+        __zero();
     if (__n > max_size())
         this->__throw_length_error();
     pointer __p;
-    if (__n < __min_cap)
+    if (__n < __min_cap && !__libcpp_is_constant_evaluated())
     {
         __set_short_size(__n);
         __p = __get_short_pointer();
@@ -2029,6 +2113,7 @@
     {
         size_type __cap = __recommend(__n);
         __p = __alloc_traits::allocate(__alloc(), __cap+1);
+        __begin_lifetime(__p, __cap + 1);
         __set_long_pointer(__p);
         __set_long_cap(__cap+1);
         __set_long_size(__n);
@@ -2038,7 +2123,7 @@
 }
 
 template <class _CharT, class _Traits, class _Allocator>
-inline
+inline _LIBCPP_CONSTEXPR_AFTER_CXX17
 basic_string<_CharT, _Traits, _Allocator>::basic_string(size_type __n, _CharT __c)
      : __r_(__default_init_tag(), __default_init_tag())
 {
@@ -2049,7 +2134,7 @@
 }
 
 template <class _CharT, class _Traits, class _Allocator>
-template <class>
+template <class> _LIBCPP_CONSTEXPR_AFTER_CXX17
 basic_string<_CharT, _Traits, _Allocator>::basic_string(size_type __n, _CharT __c, const _Allocator& __a)
     : __r_(__default_init_tag(), __a)
 {
@@ -2060,6 +2145,7 @@
 }
 
 template <class _CharT, class _Traits, class _Allocator>
+_LIBCPP_CONSTEXPR_AFTER_CXX17
 basic_string<_CharT, _Traits, _Allocator>::basic_string(const basic_string& __str,
                                                         size_type __pos, size_type __n,
                                                         const _Allocator& __a)
@@ -2075,7 +2161,7 @@
 }
 
 template <class _CharT, class _Traits, class _Allocator>
-inline
+inline _LIBCPP_CONSTEXPR_AFTER_CXX17
 basic_string<_CharT, _Traits, _Allocator>::basic_string(const basic_string& __str, size_type __pos,
                                                         const _Allocator& __a)
     : __r_(__default_init_tag(), __a)
@@ -2091,6 +2177,7 @@
 
 template <class _CharT, class _Traits, class _Allocator>
 template <class _Tp, class>
+_LIBCPP_CONSTEXPR_AFTER_CXX17
 basic_string<_CharT, _Traits, _Allocator>::basic_string(
              const _Tp& __t, size_type __pos, size_type __n, const allocator_type& __a)
     : __r_(__default_init_tag(), __a)
@@ -2105,6 +2192,7 @@
 
 template <class _CharT, class _Traits, class _Allocator>
 template <class _Tp, class>
+_LIBCPP_CONSTEXPR_AFTER_CXX17
 basic_string<_CharT, _Traits, _Allocator>::basic_string(const _Tp & __t)
      : __r_(__default_init_tag(), __default_init_tag())
 {
@@ -2117,6 +2205,7 @@
 
 template <class _CharT, class _Traits, class _Allocator>
 template <class _Tp, class>
+_LIBCPP_CONSTEXPR_AFTER_CXX17
 basic_string<_CharT, _Traits, _Allocator>::basic_string(const _Tp & __t, const _Allocator& __a)
     : __r_(__default_init_tag(), __a)
 {
@@ -2129,6 +2218,7 @@
 
 template <class _CharT, class _Traits, class _Allocator>
 template <class _InputIterator>
+_LIBCPP_CONSTEXPR_AFTER_CXX17
 __enable_if_t
 <
     __is_exactly_cpp17_input_iterator<_InputIterator>::value
@@ -2136,6 +2226,8 @@
 basic_string<_CharT, _Traits, _Allocator>::__init(_InputIterator __first, _InputIterator __last)
 {
     __zero();
+    if (__libcpp_is_constant_evaluated())
+        __init(size_type(), value_type());
 #ifndef _LIBCPP_NO_EXCEPTIONS
     try
     {
@@ -2155,17 +2247,20 @@
 
 template <class _CharT, class _Traits, class _Allocator>
 template <class _ForwardIterator>
+_LIBCPP_CONSTEXPR_AFTER_CXX17
 __enable_if_t
 <
     __is_cpp17_forward_iterator<_ForwardIterator>::value
 >
 basic_string<_CharT, _Traits, _Allocator>::__init(_ForwardIterator __first, _ForwardIterator __last)
 {
+    if (__libcpp_is_constant_evaluated())
+        __zero();
     size_type __sz = static_cast<size_type>(_VSTD::distance(__first, __last));
     if (__sz > max_size())
         this->__throw_length_error();
     pointer __p;
-    if (__sz < __min_cap)
+    if (__sz < __min_cap && !__libcpp_is_constant_evaluated())
     {
         __set_short_size(__sz);
         __p = __get_short_pointer();
@@ -2174,6 +2269,7 @@
     {
         size_type __cap = __recommend(__sz);
         __p = __alloc_traits::allocate(__alloc(), __cap+1);
+        __begin_lifetime(__p, __cap + 1);
         __set_long_pointer(__p);
         __set_long_cap(__cap+1);
         __set_long_size(__sz);
@@ -2197,9 +2293,15 @@
 #endif  // _LIBCPP_NO_EXCEPTIONS
 }
 
+template<class _CharT, class _Traits, class _Allocator>
+inline _LIBCPP_CONSTEXPR_AFTER_CXX17 void basic_string<_CharT, _Traits, _Allocator>::__free_memory_constexpr() {
+  if (__libcpp_is_constant_evaluated() && __get_long_pointer() != nullptr)
+    __alloc_traits::deallocate(__alloc(), __get_long_pointer(), __get_long_cap());
+}
+
 template <class _CharT, class _Traits, class _Allocator>
 template<class _InputIterator, class>
-inline
+inline _LIBCPP_CONSTEXPR_AFTER_CXX17
 basic_string<_CharT, _Traits, _Allocator>::basic_string(_InputIterator __first, _InputIterator __last)
      : __r_(__default_init_tag(), __default_init_tag())
 {
@@ -2211,7 +2313,7 @@
 
 template <class _CharT, class _Traits, class _Allocator>
 template<class _InputIterator, class>
-inline
+inline _LIBCPP_CONSTEXPR_AFTER_CXX17
 basic_string<_CharT, _Traits, _Allocator>::basic_string(_InputIterator __first, _InputIterator __last,
                                                         const allocator_type& __a)
     : __r_(__default_init_tag(), __a)
@@ -2225,7 +2327,7 @@
 #ifndef _LIBCPP_CXX03_LANG
 
 template <class _CharT, class _Traits, class _Allocator>
-inline
+inline _LIBCPP_CONSTEXPR_AFTER_CXX17
 basic_string<_CharT, _Traits, _Allocator>::basic_string(
     initializer_list<_CharT> __il)
      : __r_(__default_init_tag(), __default_init_tag())
@@ -2237,8 +2339,7 @@
 }
 
 template <class _CharT, class _Traits, class _Allocator>
-inline
-
+inline _LIBCPP_CONSTEXPR_AFTER_CXX17
 basic_string<_CharT, _Traits, _Allocator>::basic_string(
     initializer_list<_CharT> __il, const _Allocator& __a)
     : __r_(__default_init_tag(), __a)
@@ -2252,29 +2353,34 @@
 #endif // _LIBCPP_CXX03_LANG
 
 template <class _CharT, class _Traits, class _Allocator>
+_LIBCPP_CONSTEXPR_AFTER_CXX17
 basic_string<_CharT, _Traits, _Allocator>::~basic_string()
 {
 #if _LIBCPP_DEBUG_LEVEL == 2
     __get_db()->__erase_c(this);
 #endif
-    if (__is_long())
-        __alloc_traits::deallocate(__alloc(), __get_long_pointer(), __get_long_cap());
+  if (__libcpp_is_constant_evaluated())
+    __free_memory_constexpr();
+  else if (__is_long())
+    __alloc_traits::deallocate(__alloc(), __get_long_pointer(), __get_long_cap());
 }
 
 template <class _CharT, class _Traits, class _Allocator>
+_LIBCPP_CONSTEXPR_AFTER_CXX17
 void
 basic_string<_CharT, _Traits, _Allocator>::__grow_by_and_replace
     (size_type __old_cap, size_type __delta_cap, size_type __old_sz,
      size_type __n_copy,  size_type __n_del,     size_type __n_add, const value_type* __p_new_stuff)
 {
-    size_type __ms = max_size();
-    if (__delta_cap > __ms - __old_cap - 1)
+    size_type __max_size = max_size();
+    if (__delta_cap > __max_size - __old_cap - 1)
         this->__throw_length_error();
     pointer __old_p = __get_pointer();
-    size_type __cap = __old_cap < __ms / 2 - __alignment ?
+    size_type __cap = __old_cap < __max_size / 2 - __alignment ?
                           __recommend(_VSTD::max(__old_cap + __delta_cap, 2 * __old_cap)) :
-                          __ms - 1;
-    pointer __p = __alloc_traits::allocate(__alloc(), __cap+1);
+                          __max_size - 1;
+    pointer __p = __alloc_traits::allocate(__alloc(), __cap + 1);
+    __begin_lifetime(__p, __cap + 1);
     __invalidate_all_iterators();
     if (__n_copy != 0)
         traits_type::copy(_VSTD::__to_address(__p),
@@ -2295,6 +2401,7 @@
 }
 
 template <class _CharT, class _Traits, class _Allocator>
+_LIBCPP_CONSTEXPR_AFTER_CXX17
 void
 basic_string<_CharT, _Traits, _Allocator>::__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)
@@ -2307,6 +2414,7 @@
                           __recommend(_VSTD::max(__old_cap + __delta_cap, 2 * __old_cap)) :
                           __ms - 1;
     pointer __p = __alloc_traits::allocate(__alloc(), __cap+1);
+    __begin_lifetime(__p, __cap + 1);
     __invalidate_all_iterators();
     if (__n_copy != 0)
         traits_type::copy(_VSTD::__to_address(__p),
@@ -2316,7 +2424,7 @@
         traits_type::copy(_VSTD::__to_address(__p) + __n_copy + __n_add,
                           _VSTD::__to_address(__old_p) + __n_copy + __n_del,
                           __sec_cp_sz);
-    if (__old_cap+1 != __min_cap)
+    if (__old_cap+1 != __min_cap || __libcpp_is_constant_evaluated())
         __alloc_traits::deallocate(__alloc(), __old_p, __old_cap+1);
     __set_long_pointer(__p);
     __set_long_cap(__cap+1);
@@ -2326,6 +2434,7 @@
 
 template <class _CharT, class _Traits, class _Allocator>
 template <bool __is_short>
+_LIBCPP_CONSTEXPR_AFTER_CXX17
 basic_string<_CharT, _Traits, _Allocator>&
 basic_string<_CharT, _Traits, _Allocator>::__assign_no_alias(
     const value_type* __s, size_type __n) {
@@ -2344,6 +2453,7 @@
 }
 
 template <class _CharT, class _Traits, class _Allocator>
+_LIBCPP_CONSTEXPR_AFTER_CXX17
 basic_string<_CharT, _Traits, _Allocator>&
 basic_string<_CharT, _Traits, _Allocator>::__assign_external(
     const value_type* __s, size_type __n) {
@@ -2362,16 +2472,18 @@
 }
 
 template <class _CharT, class _Traits, class _Allocator>
+_LIBCPP_CONSTEXPR_AFTER_CXX17
 basic_string<_CharT, _Traits, _Allocator>&
 basic_string<_CharT, _Traits, _Allocator>::assign(const value_type* __s, size_type __n)
 {
     _LIBCPP_ASSERT(__n == 0 || __s != nullptr, "string::assign received nullptr");
-    return (__builtin_constant_p(__n) && __n < __min_cap)
+    return (__builtin_constant_p(__n) && __n < __min_cap && !__libcpp_is_constant_evaluated())
                ? __assign_short(__s, __n)
                : __assign_external(__s, __n);
 }
 
 template <class _CharT, class _Traits, class _Allocator>
+_LIBCPP_CONSTEXPR_AFTER_CXX17
 basic_string<_CharT, _Traits, _Allocator>&
 basic_string<_CharT, _Traits, _Allocator>::assign(size_type __n, value_type __c)
 {
@@ -2390,6 +2502,7 @@
 }
 
 template <class _CharT, class _Traits, class _Allocator>
+_LIBCPP_CONSTEXPR_AFTER_CXX17
 basic_string<_CharT, _Traits, _Allocator>&
 basic_string<_CharT, _Traits, _Allocator>::operator=(value_type __c)
 {
@@ -2411,6 +2524,7 @@
 }
 
 template <class _CharT, class _Traits, class _Allocator>
+_LIBCPP_CONSTEXPR_AFTER_CXX17
 basic_string<_CharT, _Traits, _Allocator>&
 basic_string<_CharT, _Traits, _Allocator>::operator=(const basic_string& __str)
 {
@@ -2432,7 +2546,7 @@
 #ifndef _LIBCPP_CXX03_LANG
 
 template <class _CharT, class _Traits, class _Allocator>
-inline
+inline _LIBCPP_CONSTEXPR_AFTER_CXX17
 void
 basic_string<_CharT, _Traits, _Allocator>::__move_assign(basic_string& __str, false_type)
     _NOEXCEPT_(__alloc_traits::is_always_equal::value)
@@ -2444,7 +2558,7 @@
 }
 
 template <class _CharT, class _Traits, class _Allocator>
-inline
+inline _LIBCPP_CONSTEXPR_AFTER_CXX17
 void
 basic_string<_CharT, _Traits, _Allocator>::__move_assign(basic_string& __str, true_type)
 #if _LIBCPP_STD_VER > 14
@@ -2465,12 +2579,17 @@
   }
   __move_assign_alloc(__str);
   __r_.first() = __str.__r_.first();
+  if (__libcpp_is_constant_evaluated())
+      __str.__zero();
+  else
+  {
   __str.__set_short_size(0);
   traits_type::assign(__str.__get_short_pointer()[0], value_type());
+  }
 }
 
 template <class _CharT, class _Traits, class _Allocator>
-inline
+inline _LIBCPP_CONSTEXPR_AFTER_CXX17
 basic_string<_CharT, _Traits, _Allocator>&
 basic_string<_CharT, _Traits, _Allocator>::operator=(basic_string&& __str)
     _NOEXCEPT_((__noexcept_move_assign_container<_Allocator, __alloc_traits>::value))
@@ -2484,6 +2603,7 @@
 
 template <class _CharT, class _Traits, class _Allocator>
 template<class _InputIterator>
+_LIBCPP_CONSTEXPR_AFTER_CXX17
 __enable_if_t
 <
      __is_exactly_cpp17_input_iterator<_InputIterator>::value,
@@ -2498,6 +2618,7 @@
 
 template <class _CharT, class _Traits, class _Allocator>
 template<class _ForwardIterator>
+_LIBCPP_CONSTEXPR_AFTER_CXX17
 __enable_if_t
 <
     __is_cpp17_forward_iterator<_ForwardIterator>::value,
@@ -2509,7 +2630,7 @@
     size_type __n = __string_is_trivial_iterator<_ForwardIterator>::value ?
         static_cast<size_type>(_VSTD::distance(__first, __last)) : 0;
 
-    if (__string_is_trivial_iterator<_ForwardIterator>::value &&
+    if (__string_is_trivial_iterator<_ForwardIterator>::value && !__libcpp_is_constant_evaluated() &&
         (__cap >= __n || !__addr_in_range(*__first)))
     {
         if (__cap < __n)
@@ -2533,6 +2654,7 @@
 }
 
 template <class _CharT, class _Traits, class _Allocator>
+_LIBCPP_CONSTEXPR_AFTER_CXX17
 basic_string<_CharT, _Traits, _Allocator>&
 basic_string<_CharT, _Traits, _Allocator>::assign(const basic_string& __str, size_type __pos, size_type __n)
 {
@@ -2550,6 +2672,7 @@
     && !__is_same_uncvref<_Tp, basic_string<_CharT, _Traits, _Allocator> >::value,
     basic_string<_CharT, _Traits, _Allocator>&
 >
+_LIBCPP_CONSTEXPR_AFTER_CXX17
 basic_string<_CharT, _Traits, _Allocator>::assign(const _Tp & __t, size_type __pos, size_type __n)
 {
     __self_view __sv = __t;
@@ -2567,12 +2690,13 @@
 }
 
 template <class _CharT, class _Traits, class _Allocator>
+_LIBCPP_CONSTEXPR_AFTER_CXX17
 basic_string<_CharT, _Traits, _Allocator>&
 basic_string<_CharT, _Traits, _Allocator>::assign(const value_type* __s)
 {
     _LIBCPP_ASSERT(__s != nullptr, "string::assign received nullptr");
     return __builtin_constant_p(*__s)
-               ? (traits_type::length(__s) < __min_cap
+               ? (traits_type::length(__s) < __min_cap && !__libcpp_is_constant_evaluated()
                       ? __assign_short(__s, traits_type::length(__s))
                       : __assign_external(__s, traits_type::length(__s)))
                : __assign_external(__s);
@@ -2580,6 +2704,7 @@
 // append
 
 template <class _CharT, class _Traits, class _Allocator>
+_LIBCPP_CONSTEXPR_AFTER_CXX17
 basic_string<_CharT, _Traits, _Allocator>&
 basic_string<_CharT, _Traits, _Allocator>::append(const value_type* __s, size_type __n)
 {
@@ -2603,6 +2728,7 @@
 }
 
 template <class _CharT, class _Traits, class _Allocator>
+_LIBCPP_CONSTEXPR_AFTER_CXX17
 basic_string<_CharT, _Traits, _Allocator>&
 basic_string<_CharT, _Traits, _Allocator>::append(size_type __n, value_type __c)
 {
@@ -2639,6 +2765,7 @@
 }
 
 template <class _CharT, class _Traits, class _Allocator>
+_LIBCPP_CONSTEXPR_AFTER_CXX17
 void
 basic_string<_CharT, _Traits, _Allocator>::push_back(value_type __c)
 {
@@ -2677,6 +2804,7 @@
 
 template <class _CharT, class _Traits, class _Allocator>
 template<class _ForwardIterator>
+_LIBCPP_CONSTEXPR_AFTER_CXX17
 __enable_if_t
 <
     __is_cpp17_forward_iterator<_ForwardIterator>::value,
@@ -2690,7 +2818,7 @@
     size_type __n = static_cast<size_type>(_VSTD::distance(__first, __last));
     if (__n)
     {
-        if (__string_is_trivial_iterator<_ForwardIterator>::value &&
+        if (!__libcpp_is_constant_evaluated() && __string_is_trivial_iterator<_ForwardIterator>::value &&
             !__addr_in_range(*__first))
         {
             if (__cap - __sz < __n)
@@ -2711,7 +2839,7 @@
 }
 
 template <class _CharT, class _Traits, class _Allocator>
-inline
+inline _LIBCPP_CONSTEXPR_AFTER_CXX17
 basic_string<_CharT, _Traits, _Allocator>&
 basic_string<_CharT, _Traits, _Allocator>::append(const basic_string& __str)
 {
@@ -2719,6 +2847,7 @@
 }
 
 template <class _CharT, class _Traits, class _Allocator>
+_LIBCPP_CONSTEXPR_AFTER_CXX17
 basic_string<_CharT, _Traits, _Allocator>&
 basic_string<_CharT, _Traits, _Allocator>::append(const basic_string& __str, size_type __pos, size_type __n)
 {
@@ -2730,6 +2859,7 @@
 
 template <class _CharT, class _Traits, class _Allocator>
 template <class _Tp>
+_LIBCPP_CONSTEXPR_AFTER_CXX17
     __enable_if_t
     <
         __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value  && !__is_same_uncvref<_Tp, basic_string<_CharT, _Traits, _Allocator> >::value,
@@ -2745,6 +2875,7 @@
 }
 
 template <class _CharT, class _Traits, class _Allocator>
+_LIBCPP_CONSTEXPR_AFTER_CXX17
 basic_string<_CharT, _Traits, _Allocator>&
 basic_string<_CharT, _Traits, _Allocator>::append(const value_type* __s)
 {
@@ -2755,38 +2886,50 @@
 // insert
 
 template <class _CharT, class _Traits, class _Allocator>
+_LIBCPP_CONSTEXPR_AFTER_CXX17
 basic_string<_CharT, _Traits, _Allocator>&
-basic_string<_CharT, _Traits, _Allocator>::insert(size_type __pos, const value_type* __s, size_type __n)
+basic_string<_CharT, _Traits, _Allocator>::insert(size_type __pos, const value_type* __s, size_type __count)
 {
-    _LIBCPP_ASSERT(__n == 0 || __s != nullptr, "string::insert received nullptr");
-    size_type __sz = size();
-    if (__pos > __sz)
+    _LIBCPP_ASSERT(__count == 0 || __s != nullptr, "string::insert received nullptr");
+    size_type __size = size();
+    if (__pos > __size)
         this->__throw_out_of_range();
-    size_type __cap = capacity();
-    if (__cap - __sz >= __n)
+    size_type __capacity = capacity();
+
+    if (__libcpp_is_constant_evaluated())
     {
-        if (__n)
+        if (__capacity - __size >= __count)
+            __grow_by_and_replace(__capacity, 0, __size, __pos, 0, __count, __s);
+        else
+            __grow_by_and_replace(__capacity, __size + __count - __capacity, __size, __pos, 0, __count, __s);
+        return *this;
+    }
+
+    if (__capacity - __size >= __count)
+    {
+        if (__count > 0)
         {
-            value_type* __p = _VSTD::__to_address(__get_pointer());
-            size_type __n_move = __sz - __pos;
+            value_type* __begin = _VSTD::__to_address(__get_pointer());
+            size_type __n_move = __size - __pos;
             if (__n_move != 0)
             {
-                if (__p + __pos <= __s && __s < __p + __sz)
-                    __s += __n;
-                traits_type::move(__p + __pos + __n, __p + __pos, __n_move);
+                if (__begin + __pos <= __s && __s < __begin + __size)
+                    __s += __count;
+                traits_type::move(__begin + __pos + __count, __begin + __pos, __n_move);
             }
-            traits_type::move(__p + __pos, __s, __n);
-            __sz += __n;
-            __set_size(__sz);
-            traits_type::assign(__p[__sz], value_type());
+            traits_type::move(__begin + __pos, __s, __count);
+            __size += __count;
+            __set_size(__size);
+            traits_type::assign(__begin[__size], value_type());
         }
     }
     else
-        __grow_by_and_replace(__cap, __sz + __n - __cap, __sz, __pos, 0, __n, __s);
+        __grow_by_and_replace(__capacity, __size + __count - __capacity, __size, __pos, 0, __count, __s);
     return *this;
 }
 
 template <class _CharT, class _Traits, class _Allocator>
+_LIBCPP_CONSTEXPR_AFTER_CXX17
 basic_string<_CharT, _Traits, _Allocator>&
 basic_string<_CharT, _Traits, _Allocator>::insert(size_type __pos, size_type __n, value_type __c)
 {
@@ -2819,6 +2962,7 @@
 
 template <class _CharT, class _Traits, class _Allocator>
 template<class _InputIterator>
+_LIBCPP_CONSTEXPR_AFTER_CXX17
 __enable_if_t
 <
    __is_exactly_cpp17_input_iterator<_InputIterator>::value,
@@ -2835,8 +2979,39 @@
     return insert(__pos, __temp.data(), __temp.data() + __temp.size());
 }
 
+template<class _CharT, class _Traits, class _Allocator>
+template<class _ForwardIterator>
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX11 void
+basic_string<_CharT, _Traits, _Allocator>::__insert_not_in_range(const size_type __ip,
+                                                                 const size_type __n,
+                                                                 _ForwardIterator __first,
+                                                                 _ForwardIterator __last)
+{
+    size_type __sz = size();
+    size_type __cap = capacity();
+    value_type* __p;
+    if (__cap - __sz >= __n)
+    {
+        __p = _VSTD::__to_address(__get_pointer());
+        size_type __n_move = __sz - __ip;
+        if (__n_move != 0)
+            traits_type::move(__p + __ip + __n, __p + __ip, __n_move);
+    }
+    else
+    {
+        __grow_by(__cap, __sz + __n - __cap, __sz, __ip, 0, __n);
+        __p = _VSTD::__to_address(__get_long_pointer());
+    }
+    __sz += __n;
+    __set_size(__sz);
+    traits_type::assign(__p[__sz], value_type());
+    for (__p += __ip; __first != __last; ++__p, (void) ++__first)
+        traits_type::assign(*__p, *__first);
+}
+
 template <class _CharT, class _Traits, class _Allocator>
 template<class _ForwardIterator>
+_LIBCPP_CONSTEXPR_AFTER_CXX17
 __enable_if_t
 <
     __is_cpp17_forward_iterator<_ForwardIterator>::value,
@@ -2853,41 +3028,21 @@
     size_type __n = static_cast<size_type>(_VSTD::distance(__first, __last));
     if (__n)
     {
-        if (__string_is_trivial_iterator<_ForwardIterator>::value &&
-            !__addr_in_range(*__first))
-        {
-            size_type __sz = size();
-            size_type __cap = capacity();
-            value_type* __p;
-            if (__cap - __sz >= __n)
-            {
-                __p = _VSTD::__to_address(__get_pointer());
-                size_type __n_move = __sz - __ip;
-                if (__n_move != 0)
-                    traits_type::move(__p + __ip + __n, __p + __ip, __n_move);
-            }
-            else
-            {
-                __grow_by(__cap, __sz + __n - __cap, __sz, __ip, 0, __n);
-                __p = _VSTD::__to_address(__get_long_pointer());
-            }
-            __sz += __n;
-            __set_size(__sz);
-            traits_type::assign(__p[__sz], value_type());
-            for (__p += __ip; __first != __last; ++__p, (void) ++__first)
-                traits_type::assign(*__p, *__first);
-        }
-        else
+        if (!__string_is_trivial_iterator<_ForwardIterator>::value || __libcpp_is_constant_evaluated() ||
+            __addr_in_range(*__first))
         {
             const basic_string __temp(__first, __last, __alloc());
-            return insert(__pos, __temp.data(), __temp.data() + __temp.size());
+            __insert_not_in_range(__ip, __n, __temp.data(), __temp.data() + __temp.size());
         }
+        else
+            __insert_not_in_range(__ip, __n, __first, __last);
+        
     }
     return begin() + __ip;
 }
 
 template <class _CharT, class _Traits, class _Allocator>
-inline
+inline _LIBCPP_CONSTEXPR_AFTER_CXX17
 basic_string<_CharT, _Traits, _Allocator>&
 basic_string<_CharT, _Traits, _Allocator>::insert(size_type __pos1, const basic_string& __str)
 {
@@ -2895,6 +3050,7 @@
 }
 
 template <class _CharT, class _Traits, class _Allocator>
+_LIBCPP_CONSTEXPR_AFTER_CXX17
 basic_string<_CharT, _Traits, _Allocator>&
 basic_string<_CharT, _Traits, _Allocator>::insert(size_type __pos1, const basic_string& __str,
                                                   size_type __pos2, size_type __n)
@@ -2907,6 +3063,7 @@
 
 template <class _CharT, class _Traits, class _Allocator>
 template <class _Tp>
+_LIBCPP_CONSTEXPR_AFTER_CXX17
 __enable_if_t
 <
     __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value  && !__is_same_uncvref<_Tp, basic_string<_CharT, _Traits, _Allocator> >::value,
@@ -2923,6 +3080,7 @@
 }
 
 template <class _CharT, class _Traits, class _Allocator>
+_LIBCPP_CONSTEXPR_AFTER_CXX17
 basic_string<_CharT, _Traits, _Allocator>&
 basic_string<_CharT, _Traits, _Allocator>::insert(size_type __pos, const value_type* __s)
 {
@@ -2931,6 +3089,7 @@
 }
 
 template <class _CharT, class _Traits, class _Allocator>
+_LIBCPP_CONSTEXPR_AFTER_CXX17
 typename basic_string<_CharT, _Traits, _Allocator>::iterator
 basic_string<_CharT, _Traits, _Allocator>::insert(const_iterator __pos, value_type __c)
 {
@@ -2957,7 +3116,7 @@
 }
 
 template <class _CharT, class _Traits, class _Allocator>
-inline
+inline _LIBCPP_CONSTEXPR_AFTER_CXX17
 typename basic_string<_CharT, _Traits, _Allocator>::iterator
 basic_string<_CharT, _Traits, _Allocator>::insert(const_iterator __pos, size_type __n, value_type __c)
 {
@@ -2973,7 +3132,21 @@
 
 // replace
 
+template<class _CharT, class _Traits, class _Allocator>
+inline _LIBCPP_CONSTEXPR_AFTER_CXX17
+void
+basic_string<_CharT, _Traits, _Allocator>::__finish_replace(size_type& __sz,
+                                                            size_type& __n1,
+                                                            size_type& __n2,
+                                                            value_type*& __p) {
+  __sz += __n2 - __n1;
+  __set_size(__sz);
+  __invalidate_iterators_past(__sz);
+  traits_type::assign(__p[__sz], value_type());
+}
+
 template <class _CharT, class _Traits, class _Allocator>
+_LIBCPP_CONSTEXPR_AFTER_CXX17
 basic_string<_CharT, _Traits, _Allocator>&
 basic_string<_CharT, _Traits, _Allocator>::replace(size_type __pos, size_type __n1, const value_type* __s, size_type __n2)
     _LIBCPP_DISABLE_UBSAN_UNSIGNED_INTEGER_CHECK
@@ -2986,6 +3159,11 @@
     size_type __cap = capacity();
     if (__cap - __sz + __n1 >= __n2)
     {
+        if (__libcpp_is_constant_evaluated()) {
+            __grow_by_and_replace(__cap, 0, __sz, __pos, __n1, __n2, __s);
+            return *this;
+        }
+
         value_type* __p = _VSTD::__to_address(__get_pointer());
         if (__n1 != __n2)
         {
@@ -2996,7 +3174,8 @@
                 {
                     traits_type::move(__p + __pos, __s, __n2);
                     traits_type::move(__p + __pos + __n2, __p + __pos + __n1, __n_move);
-                    goto __finish;
+                    __finish_replace(__sz, __n1, __n2, __p);
+                    return *this;
                 }
                 if (__p + __pos < __s && __s < __p + __sz)
                 {
@@ -3015,13 +3194,9 @@
             }
         }
         traits_type::move(__p + __pos, __s, __n2);
-__finish:
 // __sz += __n2 - __n1; in this and the below function below can cause unsigned
 // integer overflow, but this is a safe operation, so we disable the check.
-        __sz += __n2 - __n1;
-        __set_size(__sz);
-        __invalidate_iterators_past(__sz);
-        traits_type::assign(__p[__sz], value_type());
+        __finish_replace(__sz, __n1, __n2, __p);
     }
     else
         __grow_by_and_replace(__cap, __sz - __n1 + __n2 - __cap, __sz, __pos, __n1, __n2, __s);
@@ -3029,6 +3204,7 @@
 }
 
 template <class _CharT, class _Traits, class _Allocator>
+_LIBCPP_CONSTEXPR_AFTER_CXX17
 basic_string<_CharT, _Traits, _Allocator>&
 basic_string<_CharT, _Traits, _Allocator>::replace(size_type __pos, size_type __n1, size_type __n2, value_type __c)
     _LIBCPP_DISABLE_UBSAN_UNSIGNED_INTEGER_CHECK
@@ -3064,6 +3240,7 @@
 
 template <class _CharT, class _Traits, class _Allocator>
 template<class _InputIterator>
+_LIBCPP_CONSTEXPR_AFTER_CXX17
 __enable_if_t
 <
     __is_cpp17_input_iterator<_InputIterator>::value,
@@ -3077,7 +3254,7 @@
 }
 
 template <class _CharT, class _Traits, class _Allocator>
-inline
+inline _LIBCPP_CONSTEXPR_AFTER_CXX17
 basic_string<_CharT, _Traits, _Allocator>&
 basic_string<_CharT, _Traits, _Allocator>::replace(size_type __pos1, size_type __n1, const basic_string& __str)
 {
@@ -3085,6 +3262,7 @@
 }
 
 template <class _CharT, class _Traits, class _Allocator>
+_LIBCPP_CONSTEXPR_AFTER_CXX17
 basic_string<_CharT, _Traits, _Allocator>&
 basic_string<_CharT, _Traits, _Allocator>::replace(size_type __pos1, size_type __n1, const basic_string& __str,
                                                    size_type __pos2, size_type __n2)
@@ -3097,6 +3275,7 @@
 
 template <class _CharT, class _Traits, class _Allocator>
 template <class _Tp>
+_LIBCPP_CONSTEXPR_AFTER_CXX17
 __enable_if_t
 <
     __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value && !__is_same_uncvref<_Tp, basic_string<_CharT, _Traits, _Allocator> >::value,
@@ -3113,6 +3292,7 @@
 }
 
 template <class _CharT, class _Traits, class _Allocator>
+_LIBCPP_CONSTEXPR_AFTER_CXX17
 basic_string<_CharT, _Traits, _Allocator>&
 basic_string<_CharT, _Traits, _Allocator>::replace(size_type __pos, size_type __n1, const value_type* __s)
 {
@@ -3121,7 +3301,7 @@
 }
 
 template <class _CharT, class _Traits, class _Allocator>
-inline
+inline _LIBCPP_CONSTEXPR_AFTER_CXX17
 basic_string<_CharT, _Traits, _Allocator>&
 basic_string<_CharT, _Traits, _Allocator>::replace(const_iterator __i1, const_iterator __i2, const basic_string& __str)
 {
@@ -3130,7 +3310,7 @@
 }
 
 template <class _CharT, class _Traits, class _Allocator>
-inline
+inline _LIBCPP_CONSTEXPR_AFTER_CXX17
 basic_string<_CharT, _Traits, _Allocator>&
 basic_string<_CharT, _Traits, _Allocator>::replace(const_iterator __i1, const_iterator __i2, const value_type* __s, size_type __n)
 {
@@ -3138,7 +3318,7 @@
 }
 
 template <class _CharT, class _Traits, class _Allocator>
-inline
+inline _LIBCPP_CONSTEXPR_AFTER_CXX17
 basic_string<_CharT, _Traits, _Allocator>&
 basic_string<_CharT, _Traits, _Allocator>::replace(const_iterator __i1, const_iterator __i2, const value_type* __s)
 {
@@ -3146,7 +3326,7 @@
 }
 
 template <class _CharT, class _Traits, class _Allocator>
-inline
+inline _LIBCPP_CONSTEXPR_AFTER_CXX17
 basic_string<_CharT, _Traits, _Allocator>&
 basic_string<_CharT, _Traits, _Allocator>::replace(const_iterator __i1, const_iterator __i2, size_type __n, value_type __c)
 {
@@ -3158,6 +3338,7 @@
 // 'externally instantiated' erase() implementation, called when __n != npos.
 // Does not check __pos against size()
 template <class _CharT, class _Traits, class _Allocator>
+_LIBCPP_CONSTEXPR_AFTER_CXX17
 void
 basic_string<_CharT, _Traits, _Allocator>::__erase_external_with_move(
     size_type __pos, size_type __n)
@@ -3178,6 +3359,7 @@
 }
 
 template <class _CharT, class _Traits, class _Allocator>
+_LIBCPP_CONSTEXPR_AFTER_CXX17
 basic_string<_CharT, _Traits, _Allocator>&
 basic_string<_CharT, _Traits, _Allocator>::erase(size_type __pos,
                                                  size_type __n) {
@@ -3191,7 +3373,7 @@
 }
 
 template <class _CharT, class _Traits, class _Allocator>
-inline
+inline _LIBCPP_CONSTEXPR_AFTER_CXX17
 typename basic_string<_CharT, _Traits, _Allocator>::iterator
 basic_string<_CharT, _Traits, _Allocator>::erase(const_iterator __pos)
 {
@@ -3209,7 +3391,7 @@
 }
 
 template <class _CharT, class _Traits, class _Allocator>
-inline
+inline _LIBCPP_CONSTEXPR_AFTER_CXX17
 typename basic_string<_CharT, _Traits, _Allocator>::iterator
 basic_string<_CharT, _Traits, _Allocator>::erase(const_iterator __first, const_iterator __last)
 {
@@ -3226,7 +3408,7 @@
 }
 
 template <class _CharT, class _Traits, class _Allocator>
-inline
+inline _LIBCPP_CONSTEXPR_AFTER_CXX17
 void
 basic_string<_CharT, _Traits, _Allocator>::pop_back()
 {
@@ -3248,7 +3430,7 @@
 }
 
 template <class _CharT, class _Traits, class _Allocator>
-inline
+inline _LIBCPP_CONSTEXPR_AFTER_CXX17
 void
 basic_string<_CharT, _Traits, _Allocator>::clear() _NOEXCEPT
 {
@@ -3266,7 +3448,7 @@
 }
 
 template <class _CharT, class _Traits, class _Allocator>
-inline
+inline _LIBCPP_CONSTEXPR_AFTER_CXX17
 void
 basic_string<_CharT, _Traits, _Allocator>::__erase_to_end(size_type __pos)
 {
@@ -3284,6 +3466,7 @@
 }
 
 template <class _CharT, class _Traits, class _Allocator>
+_LIBCPP_CONSTEXPR_AFTER_CXX17
 void
 basic_string<_CharT, _Traits, _Allocator>::resize(size_type __n, value_type __c)
 {
@@ -3306,7 +3489,7 @@
 }
 
 template <class _CharT, class _Traits, class _Allocator>
-inline
+inline _LIBCPP_CONSTEXPR_AFTER_CXX17
 typename basic_string<_CharT, _Traits, _Allocator>::size_type
 basic_string<_CharT, _Traits, _Allocator>::max_size() const _NOEXCEPT
 {
@@ -3319,6 +3502,7 @@
 }
 
 template <class _CharT, class _Traits, class _Allocator>
+_LIBCPP_CONSTEXPR_AFTER_CXX17
 void
 basic_string<_CharT, _Traits, _Allocator>::reserve(size_type __requested_capacity)
 {
@@ -3338,6 +3522,7 @@
 }
 
 template <class _CharT, class _Traits, class _Allocator>
+_LIBCPP_CONSTEXPR_AFTER_CXX17
 void
 basic_string<_CharT, _Traits, _Allocator>::shrink_to_fit() _NOEXCEPT
 {
@@ -3348,6 +3533,7 @@
 }
 
 template <class _CharT, class _Traits, class _Allocator>
+_LIBCPP_CONSTEXPR_AFTER_CXX17
 void
 basic_string<_CharT, _Traits, _Allocator>::__shrink_or_extend(size_type __target_capacity)
 {
@@ -3356,7 +3542,7 @@
 
     pointer __new_data, __p;
     bool __was_long, __now_long;
-    if (__target_capacity == __min_cap - 1)
+    if (__target_capacity == __min_cap - 1 && !__libcpp_is_constant_evaluated())
     {
         __was_long = true;
         __now_long = false;
@@ -3366,7 +3552,10 @@
     else
     {
         if (__target_capacity > __cap)
+        {
             __new_data = __alloc_traits::allocate(__alloc(), __target_capacity+1);
+            __begin_lifetime(__new_data, __target_capacity + 1);
+        }
         else
         {
         #ifndef _LIBCPP_NO_EXCEPTIONS
@@ -3374,6 +3563,7 @@
             {
         #endif // _LIBCPP_NO_EXCEPTIONS
                 __new_data = __alloc_traits::allocate(__alloc(), __target_capacity+1);
+                __begin_lifetime(__new_data, __target_capacity + 1);
         #ifndef _LIBCPP_NO_EXCEPTIONS
             }
             catch (...)
@@ -3405,7 +3595,7 @@
 }
 
 template <class _CharT, class _Traits, class _Allocator>
-inline
+inline _LIBCPP_CONSTEXPR_AFTER_CXX17
 typename basic_string<_CharT, _Traits, _Allocator>::const_reference
 basic_string<_CharT, _Traits, _Allocator>::operator[](size_type __pos) const _NOEXCEPT
 {
@@ -3414,7 +3604,7 @@
 }
 
 template <class _CharT, class _Traits, class _Allocator>
-inline
+inline _LIBCPP_CONSTEXPR_AFTER_CXX17
 typename basic_string<_CharT, _Traits, _Allocator>::reference
 basic_string<_CharT, _Traits, _Allocator>::operator[](size_type __pos) _NOEXCEPT
 {
@@ -3423,6 +3613,7 @@
 }
 
 template <class _CharT, class _Traits, class _Allocator>
+_LIBCPP_CONSTEXPR_AFTER_CXX17
 typename basic_string<_CharT, _Traits, _Allocator>::const_reference
 basic_string<_CharT, _Traits, _Allocator>::at(size_type __n) const
 {
@@ -3432,6 +3623,7 @@
 }
 
 template <class _CharT, class _Traits, class _Allocator>
+_LIBCPP_CONSTEXPR_AFTER_CXX17
 typename basic_string<_CharT, _Traits, _Allocator>::reference
 basic_string<_CharT, _Traits, _Allocator>::at(size_type __n)
 {
@@ -3441,7 +3633,7 @@
 }
 
 template <class _CharT, class _Traits, class _Allocator>
-inline
+inline _LIBCPP_CONSTEXPR_AFTER_CXX17
 typename basic_string<_CharT, _Traits, _Allocator>::reference
 basic_string<_CharT, _Traits, _Allocator>::front() _NOEXCEPT
 {
@@ -3450,7 +3642,7 @@
 }
 
 template <class _CharT, class _Traits, class _Allocator>
-inline
+inline _LIBCPP_CONSTEXPR_AFTER_CXX17
 typename basic_string<_CharT, _Traits, _Allocator>::const_reference
 basic_string<_CharT, _Traits, _Allocator>::front() const _NOEXCEPT
 {
@@ -3459,7 +3651,7 @@
 }
 
 template <class _CharT, class _Traits, class _Allocator>
-inline
+inline _LIBCPP_CONSTEXPR_AFTER_CXX17
 typename basic_string<_CharT, _Traits, _Allocator>::reference
 basic_string<_CharT, _Traits, _Allocator>::back() _NOEXCEPT
 {
@@ -3468,7 +3660,7 @@
 }
 
 template <class _CharT, class _Traits, class _Allocator>
-inline
+inline _LIBCPP_CONSTEXPR_AFTER_CXX17
 typename basic_string<_CharT, _Traits, _Allocator>::const_reference
 basic_string<_CharT, _Traits, _Allocator>::back() const _NOEXCEPT
 {
@@ -3477,6 +3669,7 @@
 }
 
 template <class _CharT, class _Traits, class _Allocator>
+_LIBCPP_CONSTEXPR_AFTER_CXX17
 typename basic_string<_CharT, _Traits, _Allocator>::size_type
 basic_string<_CharT, _Traits, _Allocator>::copy(value_type* __s, size_type __n, size_type __pos) const
 {
@@ -3489,7 +3682,7 @@
 }
 
 template <class _CharT, class _Traits, class _Allocator>
-inline
+inline _LIBCPP_CONSTEXPR_AFTER_CXX17
 basic_string<_CharT, _Traits, _Allocator>
 basic_string<_CharT, _Traits, _Allocator>::substr(size_type __pos, size_type __n) const
 {
@@ -3497,7 +3690,7 @@
 }
 
 template <class _CharT, class _Traits, class _Allocator>
-inline
+inline _LIBCPP_CONSTEXPR_AFTER_CXX17
 void
 basic_string<_CharT, _Traits, _Allocator>::swap(basic_string& __str)
 #if _LIBCPP_STD_VER >= 14
@@ -3534,6 +3727,7 @@
 };
 
 template<class _CharT, class _Traits, class _Allocator>
+_LIBCPP_CONSTEXPR_AFTER_CXX17
 typename basic_string<_CharT, _Traits, _Allocator>::size_type
 basic_string<_CharT, _Traits, _Allocator>::find(const value_type* __s,
                                                 size_type __pos,
@@ -3545,7 +3739,7 @@
 }
 
 template<class _CharT, class _Traits, class _Allocator>
-inline
+inline _LIBCPP_CONSTEXPR_AFTER_CXX17
 typename basic_string<_CharT, _Traits, _Allocator>::size_type
 basic_string<_CharT, _Traits, _Allocator>::find(const basic_string& __str,
                                                 size_type __pos) const _NOEXCEPT
@@ -3556,6 +3750,7 @@
 
 template<class _CharT, class _Traits, class _Allocator>
 template <class _Tp>
+_LIBCPP_CONSTEXPR_AFTER_CXX17
 __enable_if_t
 <
     __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value,
@@ -3570,7 +3765,7 @@
 }
 
 template<class _CharT, class _Traits, class _Allocator>
-inline
+inline _LIBCPP_CONSTEXPR_AFTER_CXX17
 typename basic_string<_CharT, _Traits, _Allocator>::size_type
 basic_string<_CharT, _Traits, _Allocator>::find(const value_type* __s,
                                                 size_type __pos) const _NOEXCEPT
@@ -3581,6 +3776,7 @@
 }
 
 template<class _CharT, class _Traits, class _Allocator>
+_LIBCPP_CONSTEXPR_AFTER_CXX17
 typename basic_string<_CharT, _Traits, _Allocator>::size_type
 basic_string<_CharT, _Traits, _Allocator>::find(value_type __c,
                                                 size_type __pos) const _NOEXCEPT
@@ -3592,6 +3788,7 @@
 // rfind
 
 template<class _CharT, class _Traits, class _Allocator>
+_LIBCPP_CONSTEXPR_AFTER_CXX17
 typename basic_string<_CharT, _Traits, _Allocator>::size_type
 basic_string<_CharT, _Traits, _Allocator>::rfind(const value_type* __s,
                                                  size_type __pos,
@@ -3603,7 +3800,7 @@
 }
 
 template<class _CharT, class _Traits, class _Allocator>
-inline
+inline _LIBCPP_CONSTEXPR_AFTER_CXX17
 typename basic_string<_CharT, _Traits, _Allocator>::size_type
 basic_string<_CharT, _Traits, _Allocator>::rfind(const basic_string& __str,
                                                  size_type __pos) const _NOEXCEPT
@@ -3614,6 +3811,7 @@
 
 template<class _CharT, class _Traits, class _Allocator>
 template <class _Tp>
+_LIBCPP_CONSTEXPR_AFTER_CXX17
 __enable_if_t
 <
     __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value,
@@ -3628,7 +3826,7 @@
 }
 
 template<class _CharT, class _Traits, class _Allocator>
-inline
+inline _LIBCPP_CONSTEXPR_AFTER_CXX17
 typename basic_string<_CharT, _Traits, _Allocator>::size_type
 basic_string<_CharT, _Traits, _Allocator>::rfind(const value_type* __s,
                                                  size_type __pos) const _NOEXCEPT
@@ -3639,6 +3837,7 @@
 }
 
 template<class _CharT, class _Traits, class _Allocator>
+_LIBCPP_CONSTEXPR_AFTER_CXX17
 typename basic_string<_CharT, _Traits, _Allocator>::size_type
 basic_string<_CharT, _Traits, _Allocator>::rfind(value_type __c,
                                                  size_type __pos) const _NOEXCEPT
@@ -3650,6 +3849,7 @@
 // find_first_of
 
 template<class _CharT, class _Traits, class _Allocator>
+_LIBCPP_CONSTEXPR_AFTER_CXX17
 typename basic_string<_CharT, _Traits, _Allocator>::size_type
 basic_string<_CharT, _Traits, _Allocator>::find_first_of(const value_type* __s,
                                                          size_type __pos,
@@ -3661,7 +3861,7 @@
 }
 
 template<class _CharT, class _Traits, class _Allocator>
-inline
+inline _LIBCPP_CONSTEXPR_AFTER_CXX17
 typename basic_string<_CharT, _Traits, _Allocator>::size_type
 basic_string<_CharT, _Traits, _Allocator>::find_first_of(const basic_string& __str,
                                                          size_type __pos) const _NOEXCEPT
@@ -3672,6 +3872,7 @@
 
 template<class _CharT, class _Traits, class _Allocator>
 template <class _Tp>
+_LIBCPP_CONSTEXPR_AFTER_CXX17
 __enable_if_t
 <
     __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value,
@@ -3686,7 +3887,7 @@
 }
 
 template<class _CharT, class _Traits, class _Allocator>
-inline
+inline _LIBCPP_CONSTEXPR_AFTER_CXX17
 typename basic_string<_CharT, _Traits, _Allocator>::size_type
 basic_string<_CharT, _Traits, _Allocator>::find_first_of(const value_type* __s,
                                                          size_type __pos) const _NOEXCEPT
@@ -3697,7 +3898,7 @@
 }
 
 template<class _CharT, class _Traits, class _Allocator>
-inline
+inline _LIBCPP_CONSTEXPR_AFTER_CXX17
 typename basic_string<_CharT, _Traits, _Allocator>::size_type
 basic_string<_CharT, _Traits, _Allocator>::find_first_of(value_type __c,
                                                          size_type __pos) const _NOEXCEPT
@@ -3708,6 +3909,7 @@
 // find_last_of
 
 template<class _CharT, class _Traits, class _Allocator>
+_LIBCPP_CONSTEXPR_AFTER_CXX17
 typename basic_string<_CharT, _Traits, _Allocator>::size_type
 basic_string<_CharT, _Traits, _Allocator>::find_last_of(const value_type* __s,
                                                         size_type __pos,
@@ -3719,7 +3921,7 @@
 }
 
 template<class _CharT, class _Traits, class _Allocator>
-inline
+inline _LIBCPP_CONSTEXPR_AFTER_CXX17
 typename basic_string<_CharT, _Traits, _Allocator>::size_type
 basic_string<_CharT, _Traits, _Allocator>::find_last_of(const basic_string& __str,
                                                         size_type __pos) const _NOEXCEPT
@@ -3730,6 +3932,7 @@
 
 template<class _CharT, class _Traits, class _Allocator>
 template <class _Tp>
+_LIBCPP_CONSTEXPR_AFTER_CXX17
 __enable_if_t
 <
     __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value,
@@ -3744,7 +3947,7 @@
 }
 
 template<class _CharT, class _Traits, class _Allocator>
-inline
+inline _LIBCPP_CONSTEXPR_AFTER_CXX17
 typename basic_string<_CharT, _Traits, _Allocator>::size_type
 basic_string<_CharT, _Traits, _Allocator>::find_last_of(const value_type* __s,
                                                         size_type __pos) const _NOEXCEPT
@@ -3755,7 +3958,7 @@
 }
 
 template<class _CharT, class _Traits, class _Allocator>
-inline
+inline _LIBCPP_CONSTEXPR_AFTER_CXX17
 typename basic_string<_CharT, _Traits, _Allocator>::size_type
 basic_string<_CharT, _Traits, _Allocator>::find_last_of(value_type __c,
                                                         size_type __pos) const _NOEXCEPT
@@ -3766,6 +3969,7 @@
 // find_first_not_of
 
 template<class _CharT, class _Traits, class _Allocator>
+_LIBCPP_CONSTEXPR_AFTER_CXX17
 typename basic_string<_CharT, _Traits, _Allocator>::size_type
 basic_string<_CharT, _Traits, _Allocator>::find_first_not_of(const value_type* __s,
                                                              size_type __pos,
@@ -3777,7 +3981,7 @@
 }
 
 template<class _CharT, class _Traits, class _Allocator>
-inline
+inline _LIBCPP_CONSTEXPR_AFTER_CXX17
 typename basic_string<_CharT, _Traits, _Allocator>::size_type
 basic_string<_CharT, _Traits, _Allocator>::find_first_not_of(const basic_string& __str,
                                                              size_type __pos) const _NOEXCEPT
@@ -3788,6 +3992,7 @@
 
 template<class _CharT, class _Traits, class _Allocator>
 template <class _Tp>
+_LIBCPP_CONSTEXPR_AFTER_CXX17
 __enable_if_t
 <
     __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value,
@@ -3802,7 +4007,7 @@
 }
 
 template<class _CharT, class _Traits, class _Allocator>
-inline
+inline _LIBCPP_CONSTEXPR_AFTER_CXX17
 typename basic_string<_CharT, _Traits, _Allocator>::size_type
 basic_string<_CharT, _Traits, _Allocator>::find_first_not_of(const value_type* __s,
                                                              size_type __pos) const _NOEXCEPT
@@ -3813,7 +4018,7 @@
 }
 
 template<class _CharT, class _Traits, class _Allocator>
-inline
+inline _LIBCPP_CONSTEXPR_AFTER_CXX17
 typename basic_string<_CharT, _Traits, _Allocator>::size_type
 basic_string<_CharT, _Traits, _Allocator>::find_first_not_of(value_type __c,
                                                              size_type __pos) const _NOEXCEPT
@@ -3825,6 +4030,7 @@
 // find_last_not_of
 
 template<class _CharT, class _Traits, class _Allocator>
+_LIBCPP_CONSTEXPR_AFTER_CXX17
 typename basic_string<_CharT, _Traits, _Allocator>::size_type
 basic_string<_CharT, _Traits, _Allocator>::find_last_not_of(const value_type* __s,
                                                             size_type __pos,
@@ -3836,7 +4042,7 @@
 }
 
 template<class _CharT, class _Traits, class _Allocator>
-inline
+inline _LIBCPP_CONSTEXPR_AFTER_CXX17
 typename basic_string<_CharT, _Traits, _Allocator>::size_type
 basic_string<_CharT, _Traits, _Allocator>::find_last_not_of(const basic_string& __str,
                                                             size_type __pos) const _NOEXCEPT
@@ -3847,6 +4053,7 @@
 
 template<class _CharT, class _Traits, class _Allocator>
 template <class _Tp>
+_LIBCPP_CONSTEXPR_AFTER_CXX17
 __enable_if_t
 <
     __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value,
@@ -3861,7 +4068,7 @@
 }
 
 template<class _CharT, class _Traits, class _Allocator>
-inline
+inline _LIBCPP_CONSTEXPR_AFTER_CXX17
 typename basic_string<_CharT, _Traits, _Allocator>::size_type
 basic_string<_CharT, _Traits, _Allocator>::find_last_not_of(const value_type* __s,
                                                             size_type __pos) const _NOEXCEPT
@@ -3872,7 +4079,7 @@
 }
 
 template<class _CharT, class _Traits, class _Allocator>
-inline
+inline _LIBCPP_CONSTEXPR_AFTER_CXX17
 typename basic_string<_CharT, _Traits, _Allocator>::size_type
 basic_string<_CharT, _Traits, _Allocator>::find_last_not_of(value_type __c,
                                                             size_type __pos) const _NOEXCEPT
@@ -3885,6 +4092,7 @@
 
 template <class _CharT, class _Traits, class _Allocator>
 template <class _Tp>
+_LIBCPP_CONSTEXPR_AFTER_CXX17
 __enable_if_t
 <
     __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value,
@@ -3907,7 +4115,7 @@
 }
 
 template <class _CharT, class _Traits, class _Allocator>
-inline
+inline _LIBCPP_CONSTEXPR_AFTER_CXX17
 int
 basic_string<_CharT, _Traits, _Allocator>::compare(const basic_string& __str) const _NOEXCEPT
 {
@@ -3915,6 +4123,7 @@
 }
 
 template <class _CharT, class _Traits, class _Allocator>
+_LIBCPP_CONSTEXPR_AFTER_CXX17
 int
 basic_string<_CharT, _Traits, _Allocator>::compare(size_type __pos1,
                                                    size_type __n1,
@@ -3939,6 +4148,7 @@
 
 template <class _CharT, class _Traits, class _Allocator>
 template <class _Tp>
+_LIBCPP_CONSTEXPR_AFTER_CXX17
 __enable_if_t
 <
     __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value,
@@ -3953,7 +4163,7 @@
 }
 
 template <class _CharT, class _Traits, class _Allocator>
-inline
+inline _LIBCPP_CONSTEXPR_AFTER_CXX17
 int
 basic_string<_CharT, _Traits, _Allocator>::compare(size_type __pos1,
                                                    size_type __n1,
@@ -3964,6 +4174,7 @@
 
 template <class _CharT, class _Traits, class _Allocator>
 template <class _Tp>
+_LIBCPP_CONSTEXPR_AFTER_CXX17
 __enable_if_t
 <
     __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value
@@ -3981,6 +4192,7 @@
 }
 
 template <class _CharT, class _Traits, class _Allocator>
+_LIBCPP_CONSTEXPR_AFTER_CXX17
 int
 basic_string<_CharT, _Traits, _Allocator>::compare(size_type __pos1,
                                                    size_type __n1,
@@ -3992,6 +4204,7 @@
 }
 
 template <class _CharT, class _Traits, class _Allocator>
+_LIBCPP_CONSTEXPR_AFTER_CXX17
 int
 basic_string<_CharT, _Traits, _Allocator>::compare(const value_type* __s) const _NOEXCEPT
 {
@@ -4000,6 +4213,7 @@
 }
 
 template <class _CharT, class _Traits, class _Allocator>
+_LIBCPP_CONSTEXPR_AFTER_CXX17
 int
 basic_string<_CharT, _Traits, _Allocator>::compare(size_type __pos1,
                                                    size_type __n1,
@@ -4012,13 +4226,13 @@
 // __invariants
 
 template<class _CharT, class _Traits, class _Allocator>
-inline
+inline _LIBCPP_CONSTEXPR_AFTER_CXX17
 bool
 basic_string<_CharT, _Traits, _Allocator>::__invariants() const
 {
     if (size() > capacity())
         return false;
-    if (capacity() < __min_cap - 1)
+    if (capacity() < __min_cap - 1 && !__libcpp_is_constant_evaluated())
         return false;
     if (data() == nullptr)
         return false;
@@ -4030,7 +4244,7 @@
 // __clear_and_shrink
 
 template<class _CharT, class _Traits, class _Allocator>
-inline
+inline _LIBCPP_CONSTEXPR_AFTER_CXX17
 void
 basic_string<_CharT, _Traits, _Allocator>::__clear_and_shrink() _NOEXCEPT
 {
@@ -4038,16 +4252,21 @@
     if(__is_long())
     {
         __alloc_traits::deallocate(__alloc(), __get_long_pointer(), capacity() + 1);
-        __set_long_cap(0);
-        __set_short_size(0);
-        traits_type::assign(*__get_short_pointer(), value_type());
+        if (__libcpp_is_constant_evaluated())
+            __zero();
+        else
+        {
+            __set_long_cap(0);
+            __set_short_size(0);
+            traits_type::assign(*__get_short_pointer(), value_type());
+        }
     }
 }
 
 // operator==
 
 template<class _CharT, class _Traits, class _Allocator>
-inline _LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
 bool
 operator==(const basic_string<_CharT, _Traits, _Allocator>& __lhs,
            const basic_string<_CharT, _Traits, _Allocator>& __rhs) _NOEXCEPT
@@ -4059,7 +4278,7 @@
 }
 
 template<class _Allocator>
-inline _LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
 bool
 operator==(const basic_string<char, char_traits<char>, _Allocator>& __lhs,
            const basic_string<char, char_traits<char>, _Allocator>& __rhs) _NOEXCEPT
@@ -4078,7 +4297,7 @@
 }
 
 template<class _CharT, class _Traits, class _Allocator>
-inline _LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
 bool
 operator==(const _CharT* __lhs,
            const basic_string<_CharT, _Traits, _Allocator>& __rhs) _NOEXCEPT
@@ -4091,7 +4310,7 @@
 }
 
 template<class _CharT, class _Traits, class _Allocator>
-inline _LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
 bool
 operator==(const basic_string<_CharT,_Traits,_Allocator>& __lhs,
            const _CharT* __rhs) _NOEXCEPT
@@ -4104,7 +4323,7 @@
 }
 
 template<class _CharT, class _Traits, class _Allocator>
-inline _LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
 bool
 operator!=(const basic_string<_CharT,_Traits,_Allocator>& __lhs,
            const basic_string<_CharT, _Traits, _Allocator>& __rhs) _NOEXCEPT
@@ -4113,7 +4332,7 @@
 }
 
 template<class _CharT, class _Traits, class _Allocator>
-inline _LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
 bool
 operator!=(const _CharT* __lhs,
            const basic_string<_CharT, _Traits, _Allocator>& __rhs) _NOEXCEPT
@@ -4122,7 +4341,7 @@
 }
 
 template<class _CharT, class _Traits, class _Allocator>
-inline _LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
 bool
 operator!=(const basic_string<_CharT, _Traits, _Allocator>& __lhs,
            const _CharT* __rhs) _NOEXCEPT
@@ -4133,7 +4352,7 @@
 // operator<
 
 template<class _CharT, class _Traits, class _Allocator>
-inline _LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
 bool
 operator< (const basic_string<_CharT, _Traits, _Allocator>& __lhs,
            const basic_string<_CharT, _Traits, _Allocator>& __rhs) _NOEXCEPT
@@ -4142,7 +4361,7 @@
 }
 
 template<class _CharT, class _Traits, class _Allocator>
-inline _LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
 bool
 operator< (const basic_string<_CharT, _Traits, _Allocator>& __lhs,
            const _CharT* __rhs) _NOEXCEPT
@@ -4151,7 +4370,7 @@
 }
 
 template<class _CharT, class _Traits, class _Allocator>
-inline _LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
 bool
 operator< (const _CharT* __lhs,
            const basic_string<_CharT, _Traits, _Allocator>& __rhs) _NOEXCEPT
@@ -4162,7 +4381,7 @@
 // operator>
 
 template<class _CharT, class _Traits, class _Allocator>
-inline _LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
 bool
 operator> (const basic_string<_CharT, _Traits, _Allocator>& __lhs,
            const basic_string<_CharT, _Traits, _Allocator>& __rhs) _NOEXCEPT
@@ -4171,7 +4390,7 @@
 }
 
 template<class _CharT, class _Traits, class _Allocator>
-inline _LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
 bool
 operator> (const basic_string<_CharT, _Traits, _Allocator>& __lhs,
            const _CharT* __rhs) _NOEXCEPT
@@ -4180,7 +4399,7 @@
 }
 
 template<class _CharT, class _Traits, class _Allocator>
-inline _LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
 bool
 operator> (const _CharT* __lhs,
            const basic_string<_CharT, _Traits, _Allocator>& __rhs) _NOEXCEPT
@@ -4191,7 +4410,7 @@
 // operator<=
 
 template<class _CharT, class _Traits, class _Allocator>
-inline _LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
 bool
 operator<=(const basic_string<_CharT, _Traits, _Allocator>& __lhs,
            const basic_string<_CharT, _Traits, _Allocator>& __rhs) _NOEXCEPT
@@ -4200,7 +4419,7 @@
 }
 
 template<class _CharT, class _Traits, class _Allocator>
-inline _LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
 bool
 operator<=(const basic_string<_CharT, _Traits, _Allocator>& __lhs,
            const _CharT* __rhs) _NOEXCEPT
@@ -4209,7 +4428,7 @@
 }
 
 template<class _CharT, class _Traits, class _Allocator>
-inline _LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
 bool
 operator<=(const _CharT* __lhs,
            const basic_string<_CharT, _Traits, _Allocator>& __rhs) _NOEXCEPT
@@ -4220,7 +4439,7 @@
 // operator>=
 
 template<class _CharT, class _Traits, class _Allocator>
-inline _LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
 bool
 operator>=(const basic_string<_CharT, _Traits, _Allocator>& __lhs,
            const basic_string<_CharT, _Traits, _Allocator>& __rhs) _NOEXCEPT
@@ -4229,7 +4448,7 @@
 }
 
 template<class _CharT, class _Traits, class _Allocator>
-inline _LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
 bool
 operator>=(const basic_string<_CharT, _Traits, _Allocator>& __lhs,
            const _CharT* __rhs) _NOEXCEPT
@@ -4238,7 +4457,7 @@
 }
 
 template<class _CharT, class _Traits, class _Allocator>
-inline _LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
 bool
 operator>=(const _CharT* __lhs,
            const basic_string<_CharT, _Traits, _Allocator>& __rhs) _NOEXCEPT
@@ -4249,6 +4468,7 @@
 // operator +
 
 template<class _CharT, class _Traits, class _Allocator>
+_LIBCPP_CONSTEXPR_AFTER_CXX17
 basic_string<_CharT, _Traits, _Allocator>
 operator+(const basic_string<_CharT, _Traits, _Allocator>& __lhs,
           const basic_string<_CharT, _Traits, _Allocator>& __rhs)
@@ -4256,53 +4476,61 @@
     basic_string<_CharT, _Traits, _Allocator> __r(__lhs.get_allocator());
     typename basic_string<_CharT, _Traits, _Allocator>::size_type __lhs_sz = __lhs.size();
     typename basic_string<_CharT, _Traits, _Allocator>::size_type __rhs_sz = __rhs.size();
+    __r.__free_memory_constexpr();
     __r.__init(__lhs.data(), __lhs_sz, __lhs_sz + __rhs_sz);
     __r.append(__rhs.data(), __rhs_sz);
     return __r;
 }
 
 template<class _CharT, class _Traits, class _Allocator>
+_LIBCPP_CONSTEXPR_AFTER_CXX17
 basic_string<_CharT, _Traits, _Allocator>
 operator+(const _CharT* __lhs , const basic_string<_CharT,_Traits,_Allocator>& __rhs)
 {
     basic_string<_CharT, _Traits, _Allocator> __r(__rhs.get_allocator());
     typename basic_string<_CharT, _Traits, _Allocator>::size_type __lhs_sz = _Traits::length(__lhs);
     typename basic_string<_CharT, _Traits, _Allocator>::size_type __rhs_sz = __rhs.size();
+    __r.__free_memory_constexpr();
     __r.__init(__lhs, __lhs_sz, __lhs_sz + __rhs_sz);
     __r.append(__rhs.data(), __rhs_sz);
     return __r;
 }
 
 template<class _CharT, class _Traits, class _Allocator>
+_LIBCPP_CONSTEXPR_AFTER_CXX17
 basic_string<_CharT, _Traits, _Allocator>
 operator+(_CharT __lhs, const basic_string<_CharT,_Traits,_Allocator>& __rhs)
 {
     basic_string<_CharT, _Traits, _Allocator> __r(__rhs.get_allocator());
     typename basic_string<_CharT, _Traits, _Allocator>::size_type __rhs_sz = __rhs.size();
+    __r.__free_memory_constexpr();
     __r.__init(&__lhs, 1, 1 + __rhs_sz);
     __r.append(__rhs.data(), __rhs_sz);
     return __r;
 }
 
 template<class _CharT, class _Traits, class _Allocator>
-inline
+inline _LIBCPP_CONSTEXPR_AFTER_CXX17
 basic_string<_CharT, _Traits, _Allocator>
 operator+(const basic_string<_CharT, _Traits, _Allocator>& __lhs, const _CharT* __rhs)
 {
     basic_string<_CharT, _Traits, _Allocator> __r(__lhs.get_allocator());
     typename basic_string<_CharT, _Traits, _Allocator>::size_type __lhs_sz = __lhs.size();
     typename basic_string<_CharT, _Traits, _Allocator>::size_type __rhs_sz = _Traits::length(__rhs);
+    __r.__free_memory_constexpr();
     __r.__init(__lhs.data(), __lhs_sz, __lhs_sz + __rhs_sz);
     __r.append(__rhs, __rhs_sz);
     return __r;
 }
 
 template<class _CharT, class _Traits, class _Allocator>
+_LIBCPP_CONSTEXPR_AFTER_CXX17
 basic_string<_CharT, _Traits, _Allocator>
 operator+(const basic_string<_CharT, _Traits, _Allocator>& __lhs, _CharT __rhs)
 {
     basic_string<_CharT, _Traits, _Allocator> __r(__lhs.get_allocator());
     typename basic_string<_CharT, _Traits, _Allocator>::size_type __lhs_sz = __lhs.size();
+    __r.__free_memory_constexpr();
     __r.__init(__lhs.data(), __lhs_sz, __lhs_sz + 1);
     __r.push_back(__rhs);
     return __r;
@@ -4311,7 +4539,7 @@
 #ifndef _LIBCPP_CXX03_LANG
 
 template<class _CharT, class _Traits, class _Allocator>
-inline _LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
 basic_string<_CharT, _Traits, _Allocator>
 operator+(basic_string<_CharT, _Traits, _Allocator>&& __lhs, const basic_string<_CharT, _Traits, _Allocator>& __rhs)
 {
@@ -4319,7 +4547,7 @@
 }
 
 template<class _CharT, class _Traits, class _Allocator>
-inline _LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
 basic_string<_CharT, _Traits, _Allocator>
 operator+(const basic_string<_CharT, _Traits, _Allocator>& __lhs, basic_string<_CharT, _Traits, _Allocator>&& __rhs)
 {
@@ -4327,7 +4555,7 @@
 }
 
 template<class _CharT, class _Traits, class _Allocator>
-inline _LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
 basic_string<_CharT, _Traits, _Allocator>
 operator+(basic_string<_CharT, _Traits, _Allocator>&& __lhs, basic_string<_CharT, _Traits, _Allocator>&& __rhs)
 {
@@ -4335,7 +4563,7 @@
 }
 
 template<class _CharT, class _Traits, class _Allocator>
-inline _LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
 basic_string<_CharT, _Traits, _Allocator>
 operator+(const _CharT* __lhs , basic_string<_CharT,_Traits,_Allocator>&& __rhs)
 {
@@ -4343,7 +4571,7 @@
 }
 
 template<class _CharT, class _Traits, class _Allocator>
-inline _LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
 basic_string<_CharT, _Traits, _Allocator>
 operator+(_CharT __lhs, basic_string<_CharT,_Traits,_Allocator>&& __rhs)
 {
@@ -4352,7 +4580,7 @@
 }
 
 template<class _CharT, class _Traits, class _Allocator>
-inline _LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
 basic_string<_CharT, _Traits, _Allocator>
 operator+(basic_string<_CharT, _Traits, _Allocator>&& __lhs, const _CharT* __rhs)
 {
@@ -4360,7 +4588,7 @@
 }
 
 template<class _CharT, class _Traits, class _Allocator>
-inline _LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
 basic_string<_CharT, _Traits, _Allocator>
 operator+(basic_string<_CharT, _Traits, _Allocator>&& __lhs, _CharT __rhs)
 {
@@ -4373,7 +4601,7 @@
 // swap
 
 template<class _CharT, class _Traits, class _Allocator>
-inline _LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
 void
 swap(basic_string<_CharT, _Traits, _Allocator>& __lhs,
      basic_string<_CharT, _Traits, _Allocator>& __rhs)
@@ -4538,14 +4766,14 @@
 {
   inline namespace string_literals
   {
-    inline _LIBCPP_INLINE_VISIBILITY
+    inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     basic_string<char> operator "" s( const char *__str, size_t __len )
     {
         return basic_string<char> (__str, __len);
     }
 
 #ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
-    inline _LIBCPP_INLINE_VISIBILITY
+    inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     basic_string<wchar_t> operator "" s( const wchar_t *__str, size_t __len )
     {
         return basic_string<wchar_t> (__str, __len);
@@ -4553,20 +4781,20 @@
 #endif
 
 #ifndef _LIBCPP_HAS_NO_CHAR8_T
-    inline _LIBCPP_INLINE_VISIBILITY
+    inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     basic_string<char8_t> operator "" s(const char8_t *__str, size_t __len) _NOEXCEPT
     {
         return basic_string<char8_t> (__str, __len);
     }
 #endif
 
-    inline _LIBCPP_INLINE_VISIBILITY
+    inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     basic_string<char16_t> operator "" s( const char16_t *__str, size_t __len )
     {
         return basic_string<char16_t> (__str, __len);
     }
 
-    inline _LIBCPP_INLINE_VISIBILITY
+    inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     basic_string<char32_t> operator "" s( const char32_t *__str, size_t __len )
     {
         return basic_string<char32_t> (__str, __len);
diff --git a/libcxx/test/std/input.output/iostream.format/quoted.manip/quoted_traits.verify.cpp b/libcxx/test/std/input.output/iostream.format/quoted.manip/quoted_traits.verify.cpp
--- a/libcxx/test/std/input.output/iostream.format/quoted.manip/quoted_traits.verify.cpp
+++ b/libcxx/test/std/input.output/iostream.format/quoted.manip/quoted_traits.verify.cpp
@@ -23,16 +23,24 @@
 
 template <class charT>
 struct test_traits {
-    typedef charT char_type;
+  typedef charT char_type;
+  typedef int int_type;
+  static inline _LIBCPP_CONSTEXPR_AFTER_CXX14 void assign(char_type& __c1, const char_type& __c2) _NOEXCEPT {
+    __c1 = __c2;
+  }
+  static inline _LIBCPP_CONSTEXPR_AFTER_CXX17 char_type* assign(char_type* __s, size_t __n, char_type __a) _NOEXCEPT {
+    return std::__libcpp_is_constant_evaluated() ? _VSTD::__assign_constexpr(__s, __n, __a)
+           : __n == 0                            ? __s
+                                                 : (char_type*)_VSTD::memset(__s, to_int_type(__a), __n);
+  }
+  static inline _LIBCPP_CONSTEXPR int_type to_int_type(char_type __c) _NOEXCEPT { return int_type((unsigned char)__c); }
 };
 
-void round_trip ( const char *p ) {
-    std::stringstream ss;
-    ss << std::quoted(p);
-    std::basic_string<char, test_traits<char>> s;
-    ss >> std::quoted(s); // expected-error {{invalid operands to binary expression}}
+void round_trip(const char* p) {
+  std::stringstream ss;
+  ss << std::quoted(p);
+  std::basic_string<char, test_traits<char> > s;
+  ss >> std::quoted(s); // expected-error {{invalid operands to binary expression}}
 }
 
-int main(int, char**) {
-    round_trip("Hi Mom");
-}
+int main(int, char**) { round_trip("Hi Mom"); }
diff --git a/libcxx/test/std/strings/basic.string/cpp17_input_iterator.h b/libcxx/test/std/strings/basic.string/cpp17_input_iterator.h
--- a/libcxx/test/std/strings/basic.string/cpp17_input_iterator.h
+++ b/libcxx/test/std/strings/basic.string/cpp17_input_iterator.h
@@ -22,18 +22,18 @@
     typedef It                                                 pointer;
     typedef typename std::iterator_traits<It>::reference       reference;
 
-    cpp17_input_iterator() : it_() {}
-    explicit cpp17_input_iterator(It it) : it_(it) {}
+    TEST_CONSTEXPR_CXX20 cpp17_input_iterator() : it_() {}
+    TEST_CONSTEXPR_CXX20 explicit cpp17_input_iterator(It it) : it_(it) {}
 
-    reference operator*() const {return *it_;}
-    pointer operator->() const {return it_;}
+    TEST_CONSTEXPR_CXX20 reference operator*() const {return *it_;}
+    TEST_CONSTEXPR_CXX20 pointer operator->() const {return it_;}
 
-    cpp17_input_iterator& operator++() {++it_; return *this;}
-    cpp17_input_iterator operator++(int) {cpp17_input_iterator tmp(*this); ++(*this); return tmp;}
+    TEST_CONSTEXPR_CXX20 cpp17_input_iterator& operator++() {++it_; return *this;}
+    TEST_CONSTEXPR_CXX20 cpp17_input_iterator operator++(int) {cpp17_input_iterator tmp(*this); ++(*this); return tmp;}
 
-    friend bool operator==(const cpp17_input_iterator& x, const cpp17_input_iterator& y)
+    TEST_CONSTEXPR_CXX20 friend bool operator==(const cpp17_input_iterator& x, const cpp17_input_iterator& y)
         {return x.it_ == y.it_;}
-    friend bool operator!=(const cpp17_input_iterator& x, const cpp17_input_iterator& y)
+    TEST_CONSTEXPR_CXX20 friend bool operator!=(const cpp17_input_iterator& x, const cpp17_input_iterator& y)
         {return !(x == y);}
 };
 
diff --git a/libcxx/test/std/strings/basic.string/string.access/at.pass.cpp b/libcxx/test/std/strings/basic.string/string.access/at.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.access/at.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.access/at.pass.cpp
@@ -20,59 +20,72 @@
 #include "test_macros.h"
 
 template <class S>
-void
-test(S s, typename S::size_type pos)
-{
-    const S& cs = s;
-    if (pos < s.size())
-    {
-        assert(s.at(pos) == s[pos]);
-        assert(cs.at(pos) == cs[pos]);
-    }
+TEST_CONSTEXPR_CXX20 void test(S s, typename S::size_type pos) {
+  const S& cs = s;
+  if (pos < s.size()) {
+    assert(s.at(pos) == s[pos]);
+    assert(cs.at(pos) == cs[pos]);
+  }
 #ifndef TEST_HAS_NO_EXCEPTIONS
-    else
-    {
-        try
-        {
-            TEST_IGNORE_NODISCARD s.at(pos);
-            assert(false);
-        }
-        catch (std::out_of_range&)
-        {
-            assert(pos >= s.size());
-        }
-        try
-        {
-            TEST_IGNORE_NODISCARD cs.at(pos);
-            assert(false);
-        }
-        catch (std::out_of_range&)
-        {
-            assert(pos >= s.size());
-        }
+  else {
+    try {
+      TEST_IGNORE_NODISCARD s.at(pos);
+      assert(false);
+    } catch (std::out_of_range&) {
+      assert(pos >= s.size());
+    }
+    try {
+      TEST_IGNORE_NODISCARD cs.at(pos);
+      assert(false);
+    } catch (std::out_of_range&) {
+      assert(pos >= s.size());
     }
+  }
 #endif
 }
 
-int main(int, char**)
-{
-    {
+bool test() {
+  {
     typedef std::string S;
     test(S(), 0);
+    test(S("123"), 3);
+  }
+#if TEST_STD_VER >= 11
+  {
+    typedef std::basic_string<char, std::char_traits<char>, min_allocator<char> > S;
+    test(S(), 0);
+    test(S("123"), 3);
+  }
+#endif
+  return true;
+}
+
+TEST_CONSTEXPR_CXX20
+bool constexpr_test() {
+  {
+    typedef std::string S;
     test(S("123"), 0);
     test(S("123"), 1);
     test(S("123"), 2);
-    test(S("123"), 3);
-    }
+  }
 #if TEST_STD_VER >= 11
-    {
-    typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
-    test(S(), 0);
+  {
+    typedef std::basic_string<char, std::char_traits<char>, min_allocator<char> > S;
     test(S("123"), 0);
     test(S("123"), 1);
     test(S("123"), 2);
-    test(S("123"), 3);
-    }
+  }
+#endif
+  return true;
+}
+
+int main(int, char**) {
+
+  test();
+  constexpr_test();
+
+#if TEST_STD_VER > 17
+  static_assert(constexpr_test());
 #endif
 
   return 0;
diff --git a/libcxx/test/std/strings/basic.string/string.access/back.pass.cpp b/libcxx/test/std/strings/basic.string/string.access/back.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.access/back.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.access/back.pass.cpp
@@ -18,34 +18,40 @@
 #include "min_allocator.h"
 
 template <class S>
-void
-test(S s)
-{
-    const S& cs = s;
-    ASSERT_SAME_TYPE(decltype( s.back()), typename S::reference);
-    ASSERT_SAME_TYPE(decltype(cs.back()), typename S::const_reference);
-    LIBCPP_ASSERT_NOEXCEPT(    s.back());
-    LIBCPP_ASSERT_NOEXCEPT(   cs.back());
-    assert(&cs.back() == &cs[cs.size()-1]);
-    assert(&s.back() == &s[cs.size()-1]);
-    s.back() = typename S::value_type('z');
-    assert(s.back() == typename S::value_type('z'));
+TEST_CONSTEXPR_CXX20 void test(S s) {
+  const S& cs = s;
+  ASSERT_SAME_TYPE(decltype(s.back()), typename S::reference);
+  ASSERT_SAME_TYPE(decltype(cs.back()), typename S::const_reference);
+  LIBCPP_ASSERT_NOEXCEPT(s.back());
+  LIBCPP_ASSERT_NOEXCEPT(cs.back());
+  assert(&cs.back() == &cs[cs.size() - 1]);
+  assert(&s.back() == &s[cs.size() - 1]);
+  s.back() = typename S::value_type('z');
+  assert(s.back() == typename S::value_type('z'));
 }
 
-int main(int, char**)
-{
-    {
+TEST_CONSTEXPR_CXX20
+bool test() {
+  {
     typedef std::string S;
     test(S("1"));
     test(S("1234567890123456789012345678901234567890"));
-    }
+  }
 #if TEST_STD_VER >= 11
-    {
-    typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
+  {
+    typedef std::basic_string<char, std::char_traits<char>, min_allocator<char> > S;
     test(S("1"));
     test(S("1234567890123456789012345678901234567890"));
-    }
+  }
+#endif
+  return true;
+}
+
+int main(int, char**) {
+  test();
+#if TEST_STD_VER > 17
+  static_assert(test());
 #endif
 
-    return 0;
+  return 0;
 }
diff --git a/libcxx/test/std/strings/basic.string/string.access/front.pass.cpp b/libcxx/test/std/strings/basic.string/string.access/front.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.access/front.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.access/front.pass.cpp
@@ -18,34 +18,40 @@
 #include "min_allocator.h"
 
 template <class S>
-void
-test(S s)
-{
-    const S& cs = s;
-    ASSERT_SAME_TYPE(decltype( s.front()), typename S::reference);
-    ASSERT_SAME_TYPE(decltype(cs.front()), typename S::const_reference);
-    LIBCPP_ASSERT_NOEXCEPT(    s.front());
-    LIBCPP_ASSERT_NOEXCEPT(   cs.front());
-    assert(&cs.front() == &cs[0]);
-    assert(&s.front() == &s[0]);
-    s.front() = typename S::value_type('z');
-    assert(s.front() == typename S::value_type('z'));
+TEST_CONSTEXPR_CXX20 void test(S s) {
+  const S& cs = s;
+  ASSERT_SAME_TYPE(decltype(s.front()), typename S::reference);
+  ASSERT_SAME_TYPE(decltype(cs.front()), typename S::const_reference);
+  LIBCPP_ASSERT_NOEXCEPT(s.front());
+  LIBCPP_ASSERT_NOEXCEPT(cs.front());
+  assert(&cs.front() == &cs[0]);
+  assert(&s.front() == &s[0]);
+  s.front() = typename S::value_type('z');
+  assert(s.front() == typename S::value_type('z'));
 }
 
-int main(int, char**)
-{
-    {
+TEST_CONSTEXPR_CXX20
+bool test() {
+  {
     typedef std::string S;
     test(S("1"));
     test(S("1234567890123456789012345678901234567890"));
-    }
+  }
 #if TEST_STD_VER >= 11
-    {
-    typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
+  {
+    typedef std::basic_string<char, std::char_traits<char>, min_allocator<char> > S;
     test(S("1"));
     test(S("1234567890123456789012345678901234567890"));
-    }
+  }
+#endif
+  return true;
+}
+
+int main(int, char**) {
+  test();
+#if TEST_STD_VER > 17
+  static_assert(test());
 #endif
 
-    return 0;
+  return 0;
 }
diff --git a/libcxx/test/std/strings/basic.string/string.access/index.pass.cpp b/libcxx/test/std/strings/basic.string/string.access/index.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.access/index.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.access/index.pass.cpp
@@ -17,44 +17,50 @@
 #include "test_macros.h"
 #include "min_allocator.h"
 
-int main(int, char**)
-{
-    {
+TEST_CONSTEXPR_CXX20
+bool test() {
+  {
     typedef std::string S;
     S s("0123456789");
     const S& cs = s;
-    ASSERT_SAME_TYPE(decltype( s[0]), typename S::reference);
+    ASSERT_SAME_TYPE(decltype(s[0]), typename S::reference);
     ASSERT_SAME_TYPE(decltype(cs[0]), typename S::const_reference);
-    LIBCPP_ASSERT_NOEXCEPT(    s[0]);
-    LIBCPP_ASSERT_NOEXCEPT(   cs[0]);
-    for (S::size_type i = 0; i < cs.size(); ++i)
-    {
-        assert(s[i] == static_cast<char>('0' + i));
-        assert(cs[i] == s[i]);
+    LIBCPP_ASSERT_NOEXCEPT(s[0]);
+    LIBCPP_ASSERT_NOEXCEPT(cs[0]);
+    for (S::size_type i = 0; i < cs.size(); ++i) {
+      assert(s[i] == static_cast<char>('0' + i));
+      assert(cs[i] == s[i]);
     }
     assert(cs[cs.size()] == '\0');
     const S s2 = S();
     assert(s2[0] == '\0');
-    }
+  }
 #if TEST_STD_VER >= 11
-    {
-    typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
+  {
+    typedef std::basic_string<char, std::char_traits<char>, min_allocator<char> > S;
     S s("0123456789");
     const S& cs = s;
-    ASSERT_SAME_TYPE(decltype( s[0]), typename S::reference);
+    ASSERT_SAME_TYPE(decltype(s[0]), typename S::reference);
     ASSERT_SAME_TYPE(decltype(cs[0]), typename S::const_reference);
-    LIBCPP_ASSERT_NOEXCEPT(    s[0]);
-    LIBCPP_ASSERT_NOEXCEPT(   cs[0]);
-    for (S::size_type i = 0; i < cs.size(); ++i)
-    {
-        assert(s[i] == static_cast<char>('0' + i));
-        assert(cs[i] == s[i]);
+    LIBCPP_ASSERT_NOEXCEPT(s[0]);
+    LIBCPP_ASSERT_NOEXCEPT(cs[0]);
+    for (S::size_type i = 0; i < cs.size(); ++i) {
+      assert(s[i] == static_cast<char>('0' + i));
+      assert(cs[i] == s[i]);
     }
     assert(cs[cs.size()] == '\0');
     const S s2 = S();
     assert(s2[0] == '\0');
-    }
+  }
+#endif
+  return true;
+}
+
+int main(int, char**) {
+  test();
+#if TEST_STD_VER > 17
+  static_assert(test());
 #endif
 
-    return 0;
+  return 0;
 }
diff --git a/libcxx/test/std/strings/basic.string/string.capacity/capacity.pass.cpp b/libcxx/test/std/strings/basic.string/string.capacity/capacity.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.capacity/capacity.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.capacity/capacity.pass.cpp
@@ -18,49 +18,54 @@
 
 #include "test_macros.h"
 
-test_allocator_statistics alloc_stats;
-
 template <class S>
-void
-test(S s)
-{
-    alloc_stats.throw_after = 0;
+TEST_CONSTEXPR_CXX20 void test(S s, test_allocator_statistics& alloc_stats) {
+  alloc_stats.throw_after = 0;
 #ifndef TEST_HAS_NO_EXCEPTIONS
-    try
+  try
 #endif
-    {
-        while (s.size() < s.capacity())
-            s.push_back(typename S::value_type());
-        assert(s.size() == s.capacity());
-    }
+  {
+    while (s.size() < s.capacity())
+      s.push_back(typename S::value_type());
+    assert(s.size() == s.capacity());
+  }
 #ifndef TEST_HAS_NO_EXCEPTIONS
-    catch (...)
-    {
-        assert(false);
-    }
+  catch (...) {
+    assert(false);
+  }
 #endif
     alloc_stats.throw_after = INT_MAX;
 }
 
-int main(int, char**)
-{
-    {
+TEST_CONSTEXPR_CXX20
+bool test() {
+  {
+    test_allocator_statistics alloc_stats;
     typedef std::basic_string<char, std::char_traits<char>, test_allocator<char> > S;
     S s((test_allocator<char>(&alloc_stats)));
-    test(s);
+    test(s, alloc_stats);
     s.assign(10, 'a');
     s.erase(5);
-    test(s);
+    test(s, alloc_stats);
     s.assign(100, 'a');
     s.erase(50);
-    test(s);
-    }
+    test(s, alloc_stats);
+  }
 #if TEST_STD_VER >= 11
-    {
+  {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     S s;
     assert(s.capacity() > 0);
-    }
+  }
+#endif
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+#if TEST_STD_VER > 17
+  static_assert(test());
 #endif
 
   return 0;
diff --git a/libcxx/test/std/strings/basic.string/string.capacity/clear.pass.cpp b/libcxx/test/std/strings/basic.string/string.capacity/clear.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.capacity/clear.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.capacity/clear.pass.cpp
@@ -17,16 +17,14 @@
 #include "min_allocator.h"
 
 template <class S>
-void
-test(S s)
-{
-    s.clear();
-    assert(s.size() == 0);
+TEST_CONSTEXPR_CXX20 void test(S s) {
+  s.clear();
+  assert(s.size() == 0);
 }
 
-int main(int, char**)
-{
-    {
+TEST_CONSTEXPR_CXX20
+bool test() {
+  {
     typedef std::string S;
     S s;
     test(s);
@@ -55,5 +53,14 @@
     }
 #endif
 
+    return true;
+}
+
+int main(int, char**) {
+  test();
+#if TEST_STD_VER > 17
+  static_assert(test());
+#endif
+
   return 0;
 }
diff --git a/libcxx/test/std/strings/basic.string/string.capacity/empty.pass.cpp b/libcxx/test/std/strings/basic.string/string.capacity/empty.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.capacity/empty.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.capacity/empty.pass.cpp
@@ -17,28 +17,34 @@
 #include "min_allocator.h"
 
 template <class S>
-void
-test(const S& s)
-{
-    ASSERT_NOEXCEPT(s.empty());
-    assert(s.empty() == (s.size() == 0));
+TEST_CONSTEXPR_CXX20 void test(const S& s) {
+  ASSERT_NOEXCEPT(s.empty());
+  assert(s.empty() == (s.size() == 0));
 }
 
-int main(int, char**)
-{
-    {
+TEST_CONSTEXPR_CXX20
+bool test() {
+  {
     typedef std::string S;
     test(S());
     test(S("123"));
     test(S("12345678901234567890123456789012345678901234567890"));
-    }
+  }
 #if TEST_STD_VER >= 11
-    {
-    typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
+  {
+    typedef std::basic_string<char, std::char_traits<char>, min_allocator<char> > S;
     test(S());
     test(S("123"));
     test(S("12345678901234567890123456789012345678901234567890"));
-    }
+  }
+#endif
+  return true;
+}
+
+int main(int, char**) {
+  test();
+#if TEST_STD_VER > 17
+  static_assert(test());
 #endif
 
   return 0;
diff --git a/libcxx/test/std/strings/basic.string/string.capacity/length.pass.cpp b/libcxx/test/std/strings/basic.string/string.capacity/length.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.capacity/length.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.capacity/length.pass.cpp
@@ -17,15 +17,13 @@
 #include "min_allocator.h"
 
 template <class S>
-void
-test(const S& s)
-{
-    assert(s.length() == s.size());
+TEST_CONSTEXPR_CXX20 void test(const S& s) {
+  assert(s.length() == s.size());
 }
 
-int main(int, char**)
-{
-    {
+TEST_CONSTEXPR_CXX20
+bool test() {
+  {
     typedef std::string S;
     test(S());
     test(S("123"));
@@ -40,5 +38,14 @@
     }
 #endif
 
+    return true;
+}
+
+int main(int, char**) {
+  test();
+#if TEST_STD_VER > 17
+  static_assert(test());
+#endif
+
   return 0;
 }
diff --git a/libcxx/test/std/strings/basic.string/string.capacity/reserve_size.pass.cpp b/libcxx/test/std/strings/basic.string/string.capacity/reserve_size.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.capacity/reserve_size.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.capacity/reserve_size.pass.cpp
@@ -23,82 +23,78 @@
 #include "min_allocator.h"
 
 template <class S>
-void
-test(typename S::size_type min_cap, typename S::size_type erased_index, typename S::size_type res_arg)
-{
-    S s(min_cap, 'a');
-    s.erase(erased_index);
-    assert(s.size() == erased_index);
-    assert(s.capacity() >= min_cap); // Check that we really have at least this capacity.
+void test(typename S::size_type min_cap, typename S::size_type erased_index, typename S::size_type res_arg) {
+  S s(min_cap, 'a');
+  s.erase(erased_index);
+  assert(s.size() == erased_index);
+  assert(s.capacity() >= min_cap); // Check that we really have at least this capacity.
 
 #if TEST_STD_VER > 17
-    typename S::size_type old_cap = s.capacity();
+  typename S::size_type old_cap = s.capacity();
 #endif
-    S s0 = s;
-    if (res_arg <= s.max_size())
-    {
-        s.reserve(res_arg);
-        LIBCPP_ASSERT(s.__invariants());
-        assert(s == s0);
-        assert(s.capacity() >= res_arg);
-        assert(s.capacity() >= s.size());
+  S s0 = s;
+  if (res_arg <= s.max_size()) {
+    s.reserve(res_arg);
+    LIBCPP_ASSERT(s.__invariants());
+    assert(s == s0);
+    assert(s.capacity() >= res_arg);
+    assert(s.capacity() >= s.size());
 #if TEST_STD_VER > 17
-        assert(s.capacity() >= old_cap); // reserve never shrinks as of P0966 (C++20)
+    assert(s.capacity() >= old_cap); // reserve never shrinks as of P0966 (C++20)
 #endif
-    }
+  }
 #ifndef TEST_HAS_NO_EXCEPTIONS
-    else
-    {
-        try
-        {
-            s.reserve(res_arg);
-            LIBCPP_ASSERT(s.__invariants());
-            assert(false);
-        }
-        catch (std::length_error&)
-        {
-            assert(res_arg > s.max_size());
-        }
+  else {
+    try {
+      s.reserve(res_arg);
+      LIBCPP_ASSERT(s.__invariants());
+      assert(false);
+    } catch (std::length_error&) {
+      assert(res_arg > s.max_size());
     }
+  }
 #endif
 }
 
-int main(int, char**)
-{
-    {
+void test() {
+  {
     typedef std::string S;
     {
-    test<S>(0, 0, 5);
-    test<S>(0, 0, 10);
-    test<S>(0, 0, 50);
+      test<S>(0, 0, 5);
+      test<S>(0, 0, 10);
+      test<S>(0, 0, 50);
     }
     {
-    test<S>(100, 50, 5);
-    test<S>(100, 50, 10);
-    test<S>(100, 50, 50);
-    test<S>(100, 50, 100);
-    test<S>(100, 50, 1000);
-    test<S>(100, 50, S::npos);
-    }
+      test<S>(100, 50, 5);
+      test<S>(100, 50, 10);
+      test<S>(100, 50, 50);
+      test<S>(100, 50, 100);
+      test<S>(100, 50, 1000);
+      test<S>(100, 50, S::npos);
     }
+  }
 #if TEST_STD_VER >= 11
+  {
+    typedef std::basic_string<char, std::char_traits<char>, min_allocator<char> > S;
     {
-    typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
-    {
-    test<S>(0, 0, 5);
-    test<S>(0, 0, 10);
-    test<S>(0, 0, 50);
+      test<S>(0, 0, 5);
+      test<S>(0, 0, 10);
+      test<S>(0, 0, 50);
     }
     {
-    test<S>(100, 50, 5);
-    test<S>(100, 50, 10);
-    test<S>(100, 50, 50);
-    test<S>(100, 50, 100);
-    test<S>(100, 50, 1000);
-    test<S>(100, 50, S::npos);
-    }
+      test<S>(100, 50, 5);
+      test<S>(100, 50, 10);
+      test<S>(100, 50, 50);
+      test<S>(100, 50, 100);
+      test<S>(100, 50, 1000);
+      test<S>(100, 50, S::npos);
     }
+  }
 #endif
+}
+
+int main(int, char**) {
+  test();
 
   return 0;
 }
diff --git a/libcxx/test/std/strings/basic.string/string.capacity/resize_size.pass.cpp b/libcxx/test/std/strings/basic.string/string.capacity/resize_size.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.capacity/resize_size.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.capacity/resize_size.pass.cpp
@@ -18,18 +18,14 @@
 #include "min_allocator.h"
 
 template <class S>
-void
-test(S s, typename S::size_type n, S expected)
-{
-    if (n <= s.max_size())
-    {
-        s.resize(n);
-        LIBCPP_ASSERT(s.__invariants());
-        assert(s == expected);
-    }
+TEST_CONSTEXPR_CXX20 void test(S s, typename S::size_type n, S expected) {
+  if (n <= s.max_size()) {
+    s.resize(n);
+    LIBCPP_ASSERT(s.__invariants());
+    assert(s == expected);
+  }
 #ifndef TEST_HAS_NO_EXCEPTIONS
-    else
-    {
+  else {
         try
         {
             s.resize(n);
@@ -43,9 +39,24 @@
 #endif
 }
 
-int main(int, char**)
-{
-    {
+bool test() {
+  {
+    typedef std::string S;
+    test(S(), S::npos, S("not going to happen"));
+  }
+#if TEST_STD_VER >= 11
+  {
+    typedef std::basic_string<char, std::char_traits<char>, min_allocator<char> > S;
+    test(S(), S::npos, S("not going to happen"));
+  }
+#endif
+
+  return true;
+}
+
+TEST_CONSTEXPR_CXX20
+bool constexpr_test() {
+  {
     typedef std::string S;
     test(S(), 0, S());
     test(S(), 1, S(1, '\0'));
@@ -62,7 +73,6 @@
          S("12345678901234567890123456789012345678901234567890"));
     test(S("12345678901234567890123456789012345678901234567890"), 60,
          S("12345678901234567890123456789012345678901234567890\0\0\0\0\0\0\0\0\0\0", 60));
-    test(S(), S::npos, S("not going to happen"));
     }
 #if TEST_STD_VER >= 11
     {
@@ -82,9 +92,20 @@
          S("12345678901234567890123456789012345678901234567890"));
     test(S("12345678901234567890123456789012345678901234567890"), 60,
          S("12345678901234567890123456789012345678901234567890\0\0\0\0\0\0\0\0\0\0", 60));
-    test(S(), S::npos, S("not going to happen"));
     }
 #endif
 
+    return true;
+}
+
+int main(int, char**) {
+
+  test();
+  constexpr_test();
+
+#if TEST_STD_VER > 17
+  static_assert(constexpr_test());
+#endif
+
   return 0;
 }
diff --git a/libcxx/test/std/strings/basic.string/string.capacity/resize_size_char.pass.cpp b/libcxx/test/std/strings/basic.string/string.capacity/resize_size_char.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.capacity/resize_size_char.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.capacity/resize_size_char.pass.cpp
@@ -18,18 +18,14 @@
 #include "min_allocator.h"
 
 template <class S>
-void
-test(S s, typename S::size_type n, typename S::value_type c, S expected)
-{
-    if (n <= s.max_size())
-    {
-        s.resize(n, c);
-        LIBCPP_ASSERT(s.__invariants());
-        assert(s == expected);
-    }
+TEST_CONSTEXPR_CXX20 void test(S s, typename S::size_type n, typename S::value_type c, S expected) {
+  if (n <= s.max_size()) {
+    s.resize(n, c);
+    LIBCPP_ASSERT(s.__invariants());
+    assert(s == expected);
+  }
 #ifndef TEST_HAS_NO_EXCEPTIONS
-    else
-    {
+  else {
         try
         {
             s.resize(n, c);
@@ -43,9 +39,24 @@
 #endif
 }
 
-int main(int, char**)
-{
-    {
+bool test() {
+  {
+    typedef std::string S;
+    test(S(), S::npos, 'a', S("not going to happen"));
+  }
+#if TEST_STD_VER >= 11
+  {
+    typedef std::basic_string<char, std::char_traits<char>, min_allocator<char> > S;
+    test(S(), S::npos, 'a', S("not going to happen"));
+  }
+#endif
+
+  return true;
+}
+
+TEST_CONSTEXPR_CXX20
+bool constexpr_test() {
+  {
     typedef std::string S;
     test(S(), 0, 'a', S());
     test(S(), 1, 'a', S("a"));
@@ -62,7 +73,6 @@
          S("12345678901234567890123456789012345678901234567890"));
     test(S("12345678901234567890123456789012345678901234567890"), 60, 'a',
          S("12345678901234567890123456789012345678901234567890aaaaaaaaaa"));
-    test(S(), S::npos, 'a', S("not going to happen"));
     }
 #if TEST_STD_VER >= 11
     {
@@ -82,9 +92,20 @@
          S("12345678901234567890123456789012345678901234567890"));
     test(S("12345678901234567890123456789012345678901234567890"), 60, 'a',
          S("12345678901234567890123456789012345678901234567890aaaaaaaaaa"));
-    test(S(), S::npos, 'a', S("not going to happen"));
     }
 #endif
 
+    return true;
+}
+
+int main(int, char**) {
+
+  test();
+  constexpr_test();
+
+#if TEST_STD_VER > 17
+  static_assert(constexpr_test());
+#endif
+
   return 0;
 }
diff --git a/libcxx/test/std/strings/basic.string/string.capacity/shrink_to_fit.pass.cpp b/libcxx/test/std/strings/basic.string/string.capacity/shrink_to_fit.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.capacity/shrink_to_fit.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.capacity/shrink_to_fit.pass.cpp
@@ -17,21 +17,19 @@
 #include "min_allocator.h"
 
 template <class S>
-void
-test(S s)
-{
-    typename S::size_type old_cap = s.capacity();
-    S s0 = s;
-    s.shrink_to_fit();
-    LIBCPP_ASSERT(s.__invariants());
-    assert(s == s0);
-    assert(s.capacity() <= old_cap);
-    assert(s.capacity() >= s.size());
+TEST_CONSTEXPR_CXX20 void test(S s) {
+  typename S::size_type old_cap = s.capacity();
+  S s0 = s;
+  s.shrink_to_fit();
+  LIBCPP_ASSERT(s.__invariants());
+  assert(s == s0);
+  assert(s.capacity() <= old_cap);
+  assert(s.capacity() >= s.size());
 }
 
-int main(int, char**)
-{
-    {
+TEST_CONSTEXPR_CXX20
+bool test() {
+  {
     typedef std::string S;
     S s;
     test(s);
@@ -60,5 +58,14 @@
     }
 #endif
 
+    return true;
+}
+
+int main(int, char**) {
+  test();
+#if TEST_STD_VER > 17
+  static_assert(test());
+#endif
+
   return 0;
 }
diff --git a/libcxx/test/std/strings/basic.string/string.capacity/size.pass.cpp b/libcxx/test/std/strings/basic.string/string.capacity/size.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.capacity/size.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.capacity/size.pass.cpp
@@ -17,15 +17,13 @@
 #include "min_allocator.h"
 
 template <class S>
-void
-test(const S& s, typename S::size_type c)
-{
-    assert(s.size() == c);
+TEST_CONSTEXPR_CXX20 void test(const S& s, typename S::size_type c) {
+  assert(s.size() == c);
 }
 
-int main(int, char**)
-{
-    {
+TEST_CONSTEXPR_CXX20
+bool test() {
+  {
     typedef std::string S;
     test(S(), 0);
     test(S("123"), 3);
@@ -40,5 +38,14 @@
     }
 #endif
 
+    return true;
+}
+
+int main(int, char**) {
+  test();
+#if TEST_STD_VER > 17
+  static_assert(test());
+#endif
+
   return 0;
 }
diff --git a/libcxx/test/std/strings/basic.string/string.cons/T_size_size.pass.cpp b/libcxx/test/std/strings/basic.string/string.cons/T_size_size.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.cons/T_size_size.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.cons/T_size_size.pass.cpp
@@ -25,26 +25,22 @@
 #include "min_allocator.h"
 
 template <class S, class SV>
-void
-test(SV sv, std::size_t pos, std::size_t n)
-{
-    typedef typename S::traits_type T;
-    typedef typename S::allocator_type A;
-    typedef typename S::size_type Size;
-    if (pos <= sv.size())
-    {
-        S s2(sv, static_cast<Size>(pos), static_cast<Size>(n));
-        LIBCPP_ASSERT(s2.__invariants());
-        assert(pos <= sv.size());
-        std::size_t rlen = std::min(sv.size() - pos, n);
-        assert(s2.size() == rlen);
-        assert(T::compare(s2.data(), sv.data() + pos, rlen) == 0);
-        assert(s2.get_allocator() == A());
-        assert(s2.capacity() >= s2.size());
-    }
+TEST_CONSTEXPR_CXX20 void test(SV sv, std::size_t pos, std::size_t n) {
+  typedef typename S::traits_type T;
+  typedef typename S::allocator_type A;
+  typedef typename S::size_type Size;
+  if (pos <= sv.size()) {
+    S s2(sv, static_cast<Size>(pos), static_cast<Size>(n));
+    LIBCPP_ASSERT(s2.__invariants());
+    assert(pos <= sv.size());
+    std::size_t rlen = std::min(sv.size() - pos, n);
+    assert(s2.size() == rlen);
+    assert(T::compare(s2.data(), sv.data() + pos, rlen) == 0);
+    assert(s2.get_allocator() == A());
+    assert(s2.capacity() >= s2.size());
+  }
 #ifndef TEST_HAS_NO_EXCEPTIONS
-    else
-    {
+  else if (!TEST_IS_CONSTANT_EVALUATED) {
         try
         {
             S s2(sv, static_cast<Size>(pos), static_cast<Size>(n));
@@ -54,30 +50,26 @@
         {
             assert(pos > sv.size());
         }
-    }
+  }
 #endif
 }
 
 template <class S, class SV>
-void
-test(SV sv, std::size_t pos, std::size_t n, const typename S::allocator_type& a)
-{
-    typedef typename S::traits_type T;
-    typedef typename S::size_type Size;
-    if (pos <= sv.size())
-    {
-        S s2(sv, static_cast<Size>(pos), static_cast<Size>(n), a);
-        LIBCPP_ASSERT(s2.__invariants());
-        assert(pos <= sv.size());
-        std::size_t rlen = std::min(sv.size() - pos, n);
-        assert(s2.size() == rlen);
-        assert(T::compare(s2.data(), sv.data() + pos, rlen) == 0);
-        assert(s2.get_allocator() == a);
-        assert(s2.capacity() >= s2.size());
-    }
+TEST_CONSTEXPR_CXX20 void test(SV sv, std::size_t pos, std::size_t n, const typename S::allocator_type& a) {
+  typedef typename S::traits_type T;
+  typedef typename S::size_type Size;
+  if (pos <= sv.size()) {
+    S s2(sv, static_cast<Size>(pos), static_cast<Size>(n), a);
+    LIBCPP_ASSERT(s2.__invariants());
+    assert(pos <= sv.size());
+    std::size_t rlen = std::min(sv.size() - pos, n);
+    assert(s2.size() == rlen);
+    assert(T::compare(s2.data(), sv.data() + pos, rlen) == 0);
+    assert(s2.get_allocator() == a);
+    assert(s2.capacity() >= s2.size());
+  }
 #ifndef TEST_HAS_NO_EXCEPTIONS
-    else
-    {
+  else if (!TEST_IS_CONSTANT_EVALUATED) {
         try
         {
             S s2(sv, static_cast<Size>(pos), static_cast<Size>(n), a);
@@ -87,14 +79,13 @@
         {
             assert(pos > sv.size());
         }
-    }
+  }
 #endif
 }
 
-int main(int, char**)
-{
-
-    {
+TEST_CONSTEXPR_CXX20
+bool test() {
+  {
     typedef test_allocator<char> A;
     typedef std::basic_string_view<char, std::char_traits<char> > SV;
     typedef std::basic_string     <char, std::char_traits<char>, A> S;
@@ -184,5 +175,14 @@
     assert(s7 == "AB");
     }
 
+    return true;
+}
+
+int main(int, char**) {
+  test();
+#if TEST_STD_VER > 17
+  static_assert(test());
+#endif
+
   return 0;
 }
diff --git a/libcxx/test/std/strings/basic.string/string.cons/alloc.pass.cpp b/libcxx/test/std/strings/basic.string/string.cons/alloc.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.cons/alloc.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.cons/alloc.pass.cpp
@@ -18,10 +18,8 @@
 #include "min_allocator.h"
 
 template <class S>
-void
-test()
-{
-    {
+TEST_CONSTEXPR_CXX20 void test() {
+  {
 #if TEST_STD_VER > 14
     static_assert((noexcept(S{})), "" );
 #elif TEST_STD_VER >= 11
@@ -52,11 +50,9 @@
 #if TEST_STD_VER >= 11
 
 template <class S>
-void
-test2()
-{
-    {
-#if TEST_STD_VER > 14
+TEST_CONSTEXPR_CXX20 void test2() {
+  {
+#  if TEST_STD_VER > 14
     static_assert((noexcept(S{})), "" );
 #elif TEST_STD_VER >= 11
     static_assert((noexcept(S()) == noexcept(typename S::allocator_type())), "" );
@@ -85,13 +81,22 @@
 
 #endif
 
-int main(int, char**)
-{
-    test<std::basic_string<char, std::char_traits<char>, test_allocator<char> > >();
+TEST_CONSTEXPR_CXX20
+bool test() {
+  test<std::basic_string<char, std::char_traits<char>, test_allocator<char> > >();
 #if TEST_STD_VER >= 11
     test2<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
     test2<std::basic_string<char, std::char_traits<char>, explicit_allocator<char> > >();
 #endif
 
+    return true;
+}
+
+int main(int, char**) {
+  test();
+#if TEST_STD_VER > 17
+  static_assert(test());
+#endif
+
   return 0;
 }
diff --git a/libcxx/test/std/strings/basic.string/string.cons/brace_assignment.pass.cpp b/libcxx/test/std/strings/basic.string/string.cons/brace_assignment.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.cons/brace_assignment.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.cons/brace_assignment.pass.cpp
@@ -18,8 +18,8 @@
 
 #include "test_macros.h"
 
-int main(int, char**)
-{
+TEST_CONSTEXPR_CXX20
+bool test() {
   // Test that assignment from {} and {ptr, len} are allowed and are not
   // ambiguous.
   {
@@ -33,5 +33,14 @@
     assert(s == "ab");
   }
 
+  return true;
+}
+
+int main(int, char**) {
+  test();
+#if TEST_STD_VER > 17
+  static_assert(test());
+#endif
+
   return 0;
 }
diff --git a/libcxx/test/std/strings/basic.string/string.cons/char_assignment.pass.cpp b/libcxx/test/std/strings/basic.string/string.cons/char_assignment.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.cons/char_assignment.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.cons/char_assignment.pass.cpp
@@ -17,20 +17,18 @@
 #include "min_allocator.h"
 
 template <class S>
-void
-test(S s1, typename S::value_type s2)
-{
-    typedef typename S::traits_type T;
-    s1 = s2;
-    LIBCPP_ASSERT(s1.__invariants());
-    assert(s1.size() == 1);
-    assert(T::eq(s1[0], s2));
-    assert(s1.capacity() >= s1.size());
+TEST_CONSTEXPR_CXX20 void test(S s1, typename S::value_type s2) {
+  typedef typename S::traits_type T;
+  s1 = s2;
+  LIBCPP_ASSERT(s1.__invariants());
+  assert(s1.size() == 1);
+  assert(T::eq(s1[0], s2));
+  assert(s1.capacity() >= s1.size());
 }
 
-int main(int, char**)
-{
-    {
+TEST_CONSTEXPR_CXX20
+bool test() {
+  {
     typedef std::string S;
     test(S(), 'a');
     test(S("1"), 'a');
@@ -47,5 +45,14 @@
     }
 #endif
 
+    return true;
+}
+
+int main(int, char**) {
+  test();
+#if TEST_STD_VER > 17
+  static_assert(test());
+#endif
+
   return 0;
 }
diff --git a/libcxx/test/std/strings/basic.string/string.cons/copy.pass.cpp b/libcxx/test/std/strings/basic.string/string.cons/copy.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.cons/copy.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.cons/copy.pass.cpp
@@ -18,19 +18,17 @@
 #include "min_allocator.h"
 
 template <class S>
-void
-test(S s1)
-{
-    S s2 = s1;
-    LIBCPP_ASSERT(s2.__invariants());
-    assert(s2 == s1);
-    assert(s2.capacity() >= s2.size());
-    assert(s2.get_allocator() == s1.get_allocator());
+TEST_CONSTEXPR_CXX20 void test(S s1) {
+  S s2 = s1;
+  LIBCPP_ASSERT(s2.__invariants());
+  assert(s2 == s1);
+  assert(s2.capacity() >= s2.size());
+  assert(s2.get_allocator() == s1.get_allocator());
 }
 
-int main(int, char**)
-{
-    {
+TEST_CONSTEXPR_CXX20
+bool test() {
+  {
     typedef test_allocator<char> A;
     typedef std::basic_string<char, std::char_traits<char>, A> S;
     test(S(A(3)));
@@ -47,5 +45,14 @@
     }
 #endif
 
+    return true;
+}
+
+int main(int, char**) {
+  test();
+#if TEST_STD_VER > 17
+  static_assert(test());
+#endif
+
   return 0;
 }
diff --git a/libcxx/test/std/strings/basic.string/string.cons/copy_alloc.pass.cpp b/libcxx/test/std/strings/basic.string/string.cons/copy_alloc.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.cons/copy_alloc.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.cons/copy_alloc.pass.cpp
@@ -21,20 +21,29 @@
 struct alloc_imp {
     bool active;
 
+    TEST_CONSTEXPR_CXX20
     alloc_imp() : active(true) {}
 
     template <class T>
-    T* allocate(std::size_t n)
-    {
-        if (active)
-            return static_cast<T*>(std::malloc(n * sizeof(T)));
-        else
-            throw std::bad_alloc();
+    TEST_CONSTEXPR_CXX20 T* allocate(std::size_t n) {
+      if (active) {
+        if (TEST_IS_CONSTANT_EVALUATED)
+          return std::allocator<T>().allocate(n);
+        return static_cast<T*>(std::malloc(n * sizeof(T)));
+      } else
+        throw std::bad_alloc();
     }
 
     template <class T>
-    void deallocate(T* p, std::size_t) { std::free(p); }
+    TEST_CONSTEXPR_CXX20 void deallocate(T* p, std::size_t s) {
+      if (TEST_IS_CONSTANT_EVALUATED)
+        std::allocator<T>().deallocate(p, s);
+      else
+        std::free(p);
+    }
+    TEST_CONSTEXPR_CXX20
     void activate  ()                  { active = true; }
+    TEST_CONSTEXPR_CXX20
     void deactivate()                  { active = false; }
 };
 
@@ -45,69 +54,51 @@
 
     alloc_imp *imp;
 
+    TEST_CONSTEXPR_CXX20
     poca_alloc(alloc_imp *imp_) : imp (imp_) {}
 
     template <class U>
     poca_alloc(const poca_alloc<U>& other) : imp(other.imp) {}
 
+    TEST_CONSTEXPR_CXX20
     T*   allocate  (std::size_t n)       { return imp->allocate<T>(n);}
+    TEST_CONSTEXPR_CXX20
     void deallocate(T* p, std::size_t n) { imp->deallocate(p, n); }
 };
 
 template <typename T, typename U>
-bool operator==(const poca_alloc<T>& lhs, const poca_alloc<U>& rhs)
-{
-    return lhs.imp == rhs.imp;
+TEST_CONSTEXPR_CXX20 bool operator==(const poca_alloc<T>& lhs, const poca_alloc<U>& rhs) {
+  return lhs.imp == rhs.imp;
 }
 
 template <typename T, typename U>
-bool operator!=(const poca_alloc<T>& lhs, const poca_alloc<U>& rhs)
-{
-    return lhs.imp != rhs.imp;
+TEST_CONSTEXPR_CXX20 bool operator!=(const poca_alloc<T>& lhs, const poca_alloc<U>& rhs) {
+  return lhs.imp != rhs.imp;
 }
 
 template <class S>
-void test_assign(S &s1, const S& s2)
-{
-    try { s1 = s2; }
-    catch ( std::bad_alloc &) { return; }
-    assert(false);
+TEST_CONSTEXPR_CXX20 void test_assign(S& s1, const S& s2) {
+  try {
+    s1 = s2;
+  } catch (std::bad_alloc&) {
+    return;
+  }
+  assert(false);
 }
 #endif
 
-
-
 template <class S>
-void
-test(S s1, const typename S::allocator_type& a)
-{
-    S s2(s1, a);
-    LIBCPP_ASSERT(s2.__invariants());
-    assert(s2 == s1);
-    assert(s2.capacity() >= s2.size());
-    assert(s2.get_allocator() == a);
+TEST_CONSTEXPR_CXX20 void test(S s1, const typename S::allocator_type& a) {
+  S s2(s1, a);
+  LIBCPP_ASSERT(s2.__invariants());
+  assert(s2 == s1);
+  assert(s2.capacity() >= s2.size());
+  assert(s2.get_allocator() == a);
 }
 
-int main(int, char**)
-{
-    {
-    typedef test_allocator<char> A;
-    typedef std::basic_string<char, std::char_traits<char>, A> S;
-    test(S(), A(3));
-    test(S("1"), A(5));
-    test(S("1234567890123456789012345678901234567890123456789012345678901234567890"), A(7));
-    }
-#if TEST_STD_VER >= 11
-    {
-    typedef min_allocator<char> A;
-    typedef std::basic_string<char, std::char_traits<char>, A> S;
-    test(S(), A());
-    test(S("1"), A());
-    test(S("1234567890123456789012345678901234567890123456789012345678901234567890"), A());
-    }
-
-#ifndef TEST_HAS_NO_EXCEPTIONS
-    {
+bool test() {
+#if TEST_STD_VER >= 11 && !defined(TEST_HAS_NO_EXCEPTIONS)
+  {
     typedef poca_alloc<char> A;
     typedef std::basic_string<char, std::char_traits<char>, A> S;
     const char * p1 = "This is my first string";
@@ -127,6 +118,40 @@
     assert(s2 == p2);
     }
 #endif
+
+    return true;
+}
+
+TEST_CONSTEXPR_CXX20
+bool constexpr_test() {
+  {
+    typedef test_allocator<char> A;
+    typedef std::basic_string<char, std::char_traits<char>, A> S;
+    test(S(), A(3));
+    test(S("1"), A(5));
+    test(S("1234567890123456789012345678901234567890123456789012345678901234567890"), A(7));
+  }
+#if TEST_STD_VER >= 11
+  {
+    typedef min_allocator<char> A;
+    typedef std::basic_string<char, std::char_traits<char>, A> S;
+    test(S(), A());
+    test(S("1"), A());
+    test(S("1234567890123456789012345678901234567890123456789012345678901234567890"), A());
+  }
+
+#endif
+
+  return true;
+}
+
+int main(int, char**) {
+
+  test();
+  constexpr_test();
+
+#if TEST_STD_VER > 17
+  static_assert(constexpr_test());
 #endif
 
   return 0;
diff --git a/libcxx/test/std/strings/basic.string/string.cons/copy_assignment.pass.cpp b/libcxx/test/std/strings/basic.string/string.cons/copy_assignment.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.cons/copy_assignment.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.cons/copy_assignment.pass.cpp
@@ -18,18 +18,16 @@
 #include "min_allocator.h"
 
 template <class S>
-void
-test(S s1, const S& s2)
-{
-    s1 = s2;
-    LIBCPP_ASSERT(s1.__invariants());
-    assert(s1 == s2);
-    assert(s1.capacity() >= s1.size());
+TEST_CONSTEXPR_CXX20 void test(S s1, const S& s2) {
+  s1 = s2;
+  LIBCPP_ASSERT(s1.__invariants());
+  assert(s1 == s2);
+  assert(s1.capacity() >= s1.size());
 }
 
-int main(int, char**)
-{
-    {
+TEST_CONSTEXPR_CXX20
+bool test() {
+  {
     typedef std::string S;
     test(S(), S());
     test(S("1"), S());
@@ -46,7 +44,7 @@
     test(S("1234567890123456789012345678901234567890123456789012345678901234567890"
            "1234567890123456789012345678901234567890123456789012345678901234567890"),
          S("abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz"));
-    }
+  }
 #if TEST_STD_VER >= 11
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
@@ -77,5 +75,14 @@
     }
 #endif
 
+    return true;
+}
+
+int main(int, char**) {
+  test();
+#if TEST_STD_VER > 17
+  static_assert(test());
+#endif
+
   return 0;
 }
diff --git a/libcxx/test/std/strings/basic.string/string.cons/initializer_list.pass.cpp b/libcxx/test/std/strings/basic.string/string.cons/initializer_list.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.cons/initializer_list.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.cons/initializer_list.pass.cpp
@@ -19,31 +19,38 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main(int, char**)
-{
-    {
-        std::string s = {'a', 'b', 'c'};
-        assert(s == "abc");
-    }
+TEST_CONSTEXPR_CXX20
+bool test() {
+  {
+    std::string s = {'a', 'b', 'c'};
+    assert(s == "abc");
+  }
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
-    {
-        std::wstring s;
-        s = {L'a', L'b', L'c'};
-        assert(s == L"abc");
-    }
+  {
+    std::wstring s;
+    s = {L'a', L'b', L'c'};
+    assert(s == L"abc");
+  }
 #endif
-    {
-        typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
-        S s = {'a', 'b', 'c'};
-        assert(s == "abc");
-    }
-#ifndef TEST_HAS_NO_WIDE_CHARACTERS
-    {
-        typedef std::basic_string<wchar_t, std::char_traits<wchar_t>, min_allocator<wchar_t>> S;
-        S s;
-        s = {L'a', L'b', L'c'};
-        assert(s == L"abc");
-    }
+  {
+    typedef std::basic_string<char, std::char_traits<char>, min_allocator<char> > S;
+    S s = {'a', 'b', 'c'};
+    assert(s == "abc");
+  }
+  {
+    typedef std::basic_string<wchar_t, std::char_traits<wchar_t>, min_allocator<wchar_t> > S;
+    S s;
+    s = {L'a', L'b', L'c'};
+    assert(s == L"abc");
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+#if TEST_STD_VER > 17
+  static_assert(test());
 #endif
 
   return 0;
diff --git a/libcxx/test/std/strings/basic.string/string.cons/initializer_list_assignment.pass.cpp b/libcxx/test/std/strings/basic.string/string.cons/initializer_list_assignment.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.cons/initializer_list_assignment.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.cons/initializer_list_assignment.pass.cpp
@@ -18,19 +18,28 @@
 #include "test_macros.h"
 #include "min_allocator.h"
 
-int main(int, char**)
-{
-    {
-        std::string s;
-        s = {'a', 'b', 'c'};
-        assert(s == "abc");
-    }
-    {
-        typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
-        S s;
-        s = {'a', 'b', 'c'};
-        assert(s == "abc");
-    }
+TEST_CONSTEXPR_CXX20
+bool test() {
+  {
+    std::string s;
+    s = {'a', 'b', 'c'};
+    assert(s == "abc");
+  }
+  {
+    typedef std::basic_string<char, std::char_traits<char>, min_allocator<char> > S;
+    S s;
+    s = {'a', 'b', 'c'};
+    assert(s == "abc");
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+#if TEST_STD_VER > 17
+  static_assert(test());
+#endif
 
   return 0;
 }
diff --git a/libcxx/test/std/strings/basic.string/string.cons/iter_alloc.pass.cpp b/libcxx/test/std/strings/basic.string/string.cons/iter_alloc.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.cons/iter_alloc.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.cons/iter_alloc.pass.cpp
@@ -24,41 +24,37 @@
 #include "min_allocator.h"
 
 template <class It>
-void
-test(It first, It last)
-{
-    typedef typename std::iterator_traits<It>::value_type charT;
-    typedef std::basic_string<charT, std::char_traits<charT>, test_allocator<charT> > S;
-    typedef typename S::allocator_type A;
-    S s2(first, last);
-    LIBCPP_ASSERT(s2.__invariants());
-    assert(s2.size() == static_cast<std::size_t>(std::distance(first, last)));
-    unsigned i = 0;
-    for (It it = first; it != last; ++it, ++i)
-        assert(s2[i] == *it);
-    assert(s2.get_allocator() == A());
-    assert(s2.capacity() >= s2.size());
+TEST_CONSTEXPR_CXX20 void test(It first, It last) {
+  typedef typename std::iterator_traits<It>::value_type charT;
+  typedef std::basic_string<charT, std::char_traits<charT>, test_allocator<charT> > S;
+  typedef typename S::allocator_type A;
+  S s2(first, last);
+  LIBCPP_ASSERT(s2.__invariants());
+  assert(s2.size() == static_cast<std::size_t>(std::distance(first, last)));
+  unsigned i = 0;
+  for (It it = first; it != last; ++it, ++i)
+    assert(s2[i] == *it);
+  assert(s2.get_allocator() == A());
+  assert(s2.capacity() >= s2.size());
 }
 
 template <class It, class A>
-void
-test(It first, It last, const A& a)
-{
-    typedef typename std::iterator_traits<It>::value_type charT;
-    typedef std::basic_string<charT, std::char_traits<charT>, A> S;
-    S s2(first, last, a);
-    LIBCPP_ASSERT(s2.__invariants());
-    assert(s2.size() == static_cast<std::size_t>(std::distance(first, last)));
-    unsigned i = 0;
-    for (It it = first; it != last; ++it, ++i)
-        assert(s2[i] == *it);
-    assert(s2.get_allocator() == a);
-    assert(s2.capacity() >= s2.size());
+TEST_CONSTEXPR_CXX20 void test(It first, It last, const A& a) {
+  typedef typename std::iterator_traits<It>::value_type charT;
+  typedef std::basic_string<charT, std::char_traits<charT>, A> S;
+  S s2(first, last, a);
+  LIBCPP_ASSERT(s2.__invariants());
+  assert(s2.size() == static_cast<std::size_t>(std::distance(first, last)));
+  unsigned i = 0;
+  for (It it = first; it != last; ++it, ++i)
+    assert(s2[i] == *it);
+  assert(s2.get_allocator() == a);
+  assert(s2.capacity() >= s2.size());
 }
 
-int main(int, char**)
-{
-    {
+TEST_CONSTEXPR_CXX20
+bool test() {
+  {
     typedef test_allocator<char> A;
     const char* s = "12345678901234567890123456789012345678901234567890";
 
@@ -125,6 +121,14 @@
                                   std::allocator<char> >::value),
           "");
     }
+    return true;
+}
+
+int main(int, char**) {
+  test();
+#if TEST_STD_VER > 17
+  static_assert(test());
+#endif
 
   return 0;
 }
diff --git a/libcxx/test/std/strings/basic.string/string.cons/move.pass.cpp b/libcxx/test/std/strings/basic.string/string.cons/move.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.cons/move.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.cons/move.pass.cpp
@@ -20,27 +20,28 @@
 #include "min_allocator.h"
 
 template <class S>
-void
-test(S s0)
-{
-    S s1 = s0;
-    S s2 = std::move(s0);
-    LIBCPP_ASSERT(s2.__invariants());
+TEST_CONSTEXPR_CXX20 void test(S s0) {
+  S s1 = s0;
+  S s2 = std::move(s0);
+  LIBCPP_ASSERT(s2.__invariants());
+  if (TEST_IS_CONSTANT_EVALUATED)
+    LIBCPP_ASSERT(!s0.__invariants());
+  else
     LIBCPP_ASSERT(s0.__invariants());
-    assert(s2 == s1);
-    assert(s2.capacity() >= s2.size());
-    assert(s2.get_allocator() == s1.get_allocator());
+  assert(s2 == s1);
+  assert(s2.capacity() >= s2.size());
+  assert(s2.get_allocator() == s1.get_allocator());
 }
 
-int main(int, char**)
-{
-    {
+TEST_CONSTEXPR_CXX20
+bool test() {
+  {
     typedef test_allocator<char> A;
     typedef std::basic_string<char, std::char_traits<char>, A> S;
     test(S(A(3)));
     test(S("1", A(5)));
     test(S("1234567890123456789012345678901234567890123456789012345678901234567890", A(7)));
-    }
+  }
     {
     typedef min_allocator<char> A;
     typedef std::basic_string<char, std::char_traits<char>, A> S;
@@ -49,5 +50,14 @@
     test(S("1234567890123456789012345678901234567890123456789012345678901234567890", A()));
     }
 
+    return true;
+}
+
+int main(int, char**) {
+  test();
+#if TEST_STD_VER > 17
+  static_assert(test());
+#endif
+
   return 0;
 }
diff --git a/libcxx/test/std/strings/basic.string/string.cons/move_alloc.pass.cpp b/libcxx/test/std/strings/basic.string/string.cons/move_alloc.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.cons/move_alloc.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.cons/move_alloc.pass.cpp
@@ -20,22 +20,20 @@
 #include "min_allocator.h"
 
 template <class S>
-void
-test(S s0, const typename S::allocator_type& a)
-{
-    S s1 = s0;
-    S s2(std::move(s0), a);
-    LIBCPP_ASSERT(s2.__invariants());
+TEST_CONSTEXPR_CXX20 void test(S s0, const typename S::allocator_type& a) {
+  S s1 = s0;
+  S s2(std::move(s0), a);
+  LIBCPP_ASSERT(s2.__invariants());
+  if (!TEST_IS_CONSTANT_EVALUATED)
     LIBCPP_ASSERT(s0.__invariants());
-    assert(s2 == s1);
-    assert(s2.capacity() >= s2.size());
-    assert(s2.get_allocator() == a);
+  assert(s2 == s1);
+  assert(s2.capacity() >= s2.size());
+  assert(s2.get_allocator() == a);
 }
 
-int main(int, char**)
-{
-    test_allocator_statistics alloc_stats;
-    {
+TEST_CONSTEXPR_CXX20 bool test() {
+  test_allocator_statistics alloc_stats;
+  {
     typedef test_allocator<char> A;
     typedef std::basic_string<char, std::char_traits<char>, A> S;
 #if TEST_STD_VER > 14
@@ -74,5 +72,14 @@
     test(S("1234567890123456789012345678901234567890123456789012345678901234567890"), A());
     }
 
+    return true;
+}
+
+int main(int, char**) {
+  test();
+#if TEST_STD_VER > 17
+  static_assert(test());
+#endif
+
   return 0;
 }
diff --git a/libcxx/test/std/strings/basic.string/string.cons/move_assignment.pass.cpp b/libcxx/test/std/strings/basic.string/string.cons/move_assignment.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.cons/move_assignment.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.cons/move_assignment.pass.cpp
@@ -21,20 +21,21 @@
 #include "min_allocator.h"
 
 template <class S>
-void
-test(S s1, S s2)
-{
-    S s0 = s2;
-    s1 = std::move(s2);
-    LIBCPP_ASSERT(s1.__invariants());
+TEST_CONSTEXPR_CXX20 void test(S s1, S s2) {
+  S s0 = s2;
+  s1 = std::move(s2);
+  LIBCPP_ASSERT(s1.__invariants());
+  if (TEST_IS_CONSTANT_EVALUATED)
+    LIBCPP_ASSERT(!s2.__invariants());
+  else
     LIBCPP_ASSERT(s2.__invariants());
-    assert(s1 == s0);
-    assert(s1.capacity() >= s1.size());
+  assert(s1 == s0);
+  assert(s1.capacity() >= s1.size());
 }
 
-int main(int, char**)
-{
-    {
+TEST_CONSTEXPR_CXX20
+bool test() {
+  {
     typedef std::string S;
     test(S(), S());
     test(S("1"), S());
@@ -51,7 +52,7 @@
     test(S("1234567890123456789012345678901234567890123456789012345678901234567890"
            "1234567890123456789012345678901234567890123456789012345678901234567890"),
          S("abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz"));
-    }
+  }
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test(S(), S());
@@ -71,5 +72,14 @@
          S("abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz"));
     }
 
+    return true;
+}
+
+int main(int, char**) {
+  test();
+#if TEST_STD_VER > 17
+  static_assert(test());
+#endif
+
   return 0;
 }
diff --git a/libcxx/test/std/strings/basic.string/string.cons/pointer_alloc.pass.cpp b/libcxx/test/std/strings/basic.string/string.cons/pointer_alloc.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.cons/pointer_alloc.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.cons/pointer_alloc.pass.cpp
@@ -21,39 +21,35 @@
 #include "min_allocator.h"
 
 template <class charT>
-void
-test(const charT* s)
-{
-    typedef std::basic_string<charT, std::char_traits<charT>, test_allocator<charT> > S;
-    typedef typename S::traits_type T;
-    typedef typename S::allocator_type A;
-    std::size_t n = T::length(s);
-    S s2(s);
-    LIBCPP_ASSERT(s2.__invariants());
-    assert(s2.size() == n);
-    assert(T::compare(s2.data(), s, n) == 0);
-    assert(s2.get_allocator() == A());
-    assert(s2.capacity() >= s2.size());
+TEST_CONSTEXPR_CXX20 void test(const charT* s) {
+  typedef std::basic_string<charT, std::char_traits<charT>, test_allocator<charT> > S;
+  typedef typename S::traits_type T;
+  typedef typename S::allocator_type A;
+  std::size_t n = T::length(s);
+  S s2(s);
+  LIBCPP_ASSERT(s2.__invariants());
+  assert(s2.size() == n);
+  assert(T::compare(s2.data(), s, n) == 0);
+  assert(s2.get_allocator() == A());
+  assert(s2.capacity() >= s2.size());
 }
 
 template <class charT, class A>
-void
-test(const charT* s, const A& a)
-{
-    typedef std::basic_string<charT, std::char_traits<charT>, A> S;
-    typedef typename S::traits_type T;
-    std::size_t n = T::length(s);
-    S s2(s, a);
-    LIBCPP_ASSERT(s2.__invariants());
-    assert(s2.size() == n);
-    assert(T::compare(s2.data(), s, n) == 0);
-    assert(s2.get_allocator() == a);
-    assert(s2.capacity() >= s2.size());
+TEST_CONSTEXPR_CXX20 void test(const charT* s, const A& a) {
+  typedef std::basic_string<charT, std::char_traits<charT>, A> S;
+  typedef typename S::traits_type T;
+  std::size_t n = T::length(s);
+  S s2(s, a);
+  LIBCPP_ASSERT(s2.__invariants());
+  assert(s2.size() == n);
+  assert(T::compare(s2.data(), s, n) == 0);
+  assert(s2.get_allocator() == a);
+  assert(s2.capacity() >= s2.size());
 }
 
-int main(int, char**)
-{
-    {
+TEST_CONSTEXPR_CXX20
+bool test() {
+  {
     typedef test_allocator<char> A;
 
     test("");
@@ -86,5 +82,14 @@
     }
 #endif
 
+    return true;
+}
+
+int main(int, char**) {
+  test();
+#if TEST_STD_VER > 17
+  static_assert(test());
+#endif
+
   return 0;
 }
diff --git a/libcxx/test/std/strings/basic.string/string.cons/pointer_assignment.pass.cpp b/libcxx/test/std/strings/basic.string/string.cons/pointer_assignment.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.cons/pointer_assignment.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.cons/pointer_assignment.pass.cpp
@@ -18,20 +18,18 @@
 #include "min_allocator.h"
 
 template <class S>
-void
-test(S s1, const typename S::value_type* s2)
-{
-    typedef typename S::traits_type T;
-    s1 = s2;
-    LIBCPP_ASSERT(s1.__invariants());
-    assert(s1.size() == T::length(s2));
-    assert(T::compare(s1.data(), s2, s1.size()) == 0);
-    assert(s1.capacity() >= s1.size());
+TEST_CONSTEXPR_CXX20 void test(S s1, const typename S::value_type* s2) {
+  typedef typename S::traits_type T;
+  s1 = s2;
+  LIBCPP_ASSERT(s1.__invariants());
+  assert(s1.size() == T::length(s2));
+  assert(T::compare(s1.data(), s2, s1.size()) == 0);
+  assert(s1.capacity() >= s1.size());
 }
 
-int main(int, char**)
-{
-    {
+TEST_CONSTEXPR_CXX20
+bool test() {
+  {
     typedef std::string S;
     test(S(), "");
     test(S("1"), "");
@@ -48,7 +46,7 @@
     test(S("1234567890123456789012345678901234567890123456789012345678901234567890"
            "1234567890123456789012345678901234567890123456789012345678901234567890"),
          "abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz");
-    }
+  }
 #if TEST_STD_VER >= 11
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
@@ -70,5 +68,14 @@
     }
 #endif
 
+    return true;
+}
+
+int main(int, char**) {
+  test();
+#if TEST_STD_VER > 17
+  static_assert(test());
+#endif
+
   return 0;
 }
diff --git a/libcxx/test/std/strings/basic.string/string.cons/pointer_size_alloc.pass.cpp b/libcxx/test/std/strings/basic.string/string.cons/pointer_size_alloc.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.cons/pointer_size_alloc.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.cons/pointer_size_alloc.pass.cpp
@@ -20,37 +20,33 @@
 #include "min_allocator.h"
 
 template <class charT>
-void
-test(const charT* s, unsigned n)
-{
-    typedef std::basic_string<charT, std::char_traits<charT>, test_allocator<charT> > S;
-    typedef typename S::traits_type T;
-    typedef typename S::allocator_type A;
-    S s2(s, n);
-    LIBCPP_ASSERT(s2.__invariants());
-    assert(s2.size() == n);
-    assert(T::compare(s2.data(), s, n) == 0);
-    assert(s2.get_allocator() == A());
-    assert(s2.capacity() >= s2.size());
+TEST_CONSTEXPR_CXX20 void test(const charT* s, unsigned n) {
+  typedef std::basic_string<charT, std::char_traits<charT>, test_allocator<charT> > S;
+  typedef typename S::traits_type T;
+  typedef typename S::allocator_type A;
+  S s2(s, n);
+  LIBCPP_ASSERT(s2.__invariants());
+  assert(s2.size() == n);
+  assert(T::compare(s2.data(), s, n) == 0);
+  assert(s2.get_allocator() == A());
+  assert(s2.capacity() >= s2.size());
 }
 
 template <class charT, class A>
-void
-test(const charT* s, unsigned n, const A& a)
-{
-    typedef std::basic_string<charT, std::char_traits<charT>, A> S;
-    typedef typename S::traits_type T;
-    S s2(s, n, a);
-    LIBCPP_ASSERT(s2.__invariants());
-    assert(s2.size() == n);
-    assert(T::compare(s2.data(), s, n) == 0);
-    assert(s2.get_allocator() == a);
-    assert(s2.capacity() >= s2.size());
+TEST_CONSTEXPR_CXX20 void test(const charT* s, unsigned n, const A& a) {
+  typedef std::basic_string<charT, std::char_traits<charT>, A> S;
+  typedef typename S::traits_type T;
+  S s2(s, n, a);
+  LIBCPP_ASSERT(s2.__invariants());
+  assert(s2.size() == n);
+  assert(T::compare(s2.data(), s, n) == 0);
+  assert(s2.get_allocator() == a);
+  assert(s2.capacity() >= s2.size());
 }
 
-int main(int, char**)
-{
-    {
+TEST_CONSTEXPR_CXX20
+bool test() {
+  {
     typedef test_allocator<char> A;
 
     test("", 0);
@@ -91,5 +87,14 @@
     }
 #endif
 
+    return true;
+}
+
+int main(int, char**) {
+  test();
+#if TEST_STD_VER > 17
+  static_assert(test());
+#endif
+
   return 0;
 }
diff --git a/libcxx/test/std/strings/basic.string/string.cons/size_char_alloc.pass.cpp b/libcxx/test/std/strings/basic.string/string.cons/size_char_alloc.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.cons/size_char_alloc.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.cons/size_char_alloc.pass.cpp
@@ -21,68 +21,60 @@
 #include "min_allocator.h"
 
 template <class charT>
-void
-test(unsigned n, charT c)
-{
-    typedef std::basic_string<charT, std::char_traits<charT>, test_allocator<charT> > S;
-    typedef typename S::allocator_type A;
-    S s2(n, c);
-    LIBCPP_ASSERT(s2.__invariants());
-    assert(s2.size() == n);
-    for (unsigned i = 0; i < n; ++i)
-        assert(s2[i] == c);
-    assert(s2.get_allocator() == A());
-    assert(s2.capacity() >= s2.size());
+TEST_CONSTEXPR_CXX20 void test(unsigned n, charT c) {
+  typedef std::basic_string<charT, std::char_traits<charT>, test_allocator<charT> > S;
+  typedef typename S::allocator_type A;
+  S s2(n, c);
+  LIBCPP_ASSERT(s2.__invariants());
+  assert(s2.size() == n);
+  for (unsigned i = 0; i < n; ++i)
+    assert(s2[i] == c);
+  assert(s2.get_allocator() == A());
+  assert(s2.capacity() >= s2.size());
 }
 
 template <class charT, class A>
-void
-test(unsigned n, charT c, const A& a)
-{
-    typedef std::basic_string<charT, std::char_traits<charT>, A> S;
-    S s2(n, c, a);
-    LIBCPP_ASSERT(s2.__invariants());
-    assert(s2.size() == n);
-    for (unsigned i = 0; i < n; ++i)
-        assert(s2[i] == c);
-    assert(s2.get_allocator() == a);
-    assert(s2.capacity() >= s2.size());
+TEST_CONSTEXPR_CXX20 void test(unsigned n, charT c, const A& a) {
+  typedef std::basic_string<charT, std::char_traits<charT>, A> S;
+  S s2(n, c, a);
+  LIBCPP_ASSERT(s2.__invariants());
+  assert(s2.size() == n);
+  for (unsigned i = 0; i < n; ++i)
+    assert(s2[i] == c);
+  assert(s2.get_allocator() == a);
+  assert(s2.capacity() >= s2.size());
 }
 
 template <class Tp>
-void
-test(Tp n, Tp c)
-{
-    typedef char charT;
-    typedef std::basic_string<charT, std::char_traits<charT>, test_allocator<charT> > S;
-    typedef typename S::allocator_type A;
-    S s2(n, c);
-    LIBCPP_ASSERT(s2.__invariants());
-    assert(s2.size() == static_cast<std::size_t>(n));
-    for (int i = 0; i < n; ++i)
-        assert(s2[i] == c);
-    assert(s2.get_allocator() == A());
-    assert(s2.capacity() >= s2.size());
+TEST_CONSTEXPR_CXX20 void test(Tp n, Tp c) {
+  typedef char charT;
+  typedef std::basic_string<charT, std::char_traits<charT>, test_allocator<charT> > S;
+  typedef typename S::allocator_type A;
+  S s2(n, c);
+  LIBCPP_ASSERT(s2.__invariants());
+  assert(s2.size() == static_cast<std::size_t>(n));
+  for (int i = 0; i < n; ++i)
+    assert(s2[i] == c);
+  assert(s2.get_allocator() == A());
+  assert(s2.capacity() >= s2.size());
 }
 
 template <class Tp, class A>
-void
-test(Tp n, Tp c, const A& a)
-{
-    typedef char charT;
-    typedef std::basic_string<charT, std::char_traits<charT>, A> S;
-    S s2(n, c, a);
-    LIBCPP_ASSERT(s2.__invariants());
-    assert(s2.size() == static_cast<std::size_t>(n));
-    for (int i = 0; i < n; ++i)
-        assert(s2[i] == c);
-    assert(s2.get_allocator() == a);
-    assert(s2.capacity() >= s2.size());
+TEST_CONSTEXPR_CXX20 void test(Tp n, Tp c, const A& a) {
+  typedef char charT;
+  typedef std::basic_string<charT, std::char_traits<charT>, A> S;
+  S s2(n, c, a);
+  LIBCPP_ASSERT(s2.__invariants());
+  assert(s2.size() == static_cast<std::size_t>(n));
+  for (int i = 0; i < n; ++i)
+    assert(s2[i] == c);
+  assert(s2.get_allocator() == a);
+  assert(s2.capacity() >= s2.size());
 }
 
-int main(int, char**)
-{
-    {
+TEST_CONSTEXPR_CXX20
+bool test() {
+  {
     typedef test_allocator<char> A;
 
     test(0, 'a');
@@ -120,6 +112,14 @@
     test(static_cast<char>(100), static_cast<char>(65), A());
     }
 #endif
+    return true;
+}
+
+int main(int, char**) {
+  test();
+#if TEST_STD_VER > 17
+  static_assert(test());
+#endif
 
   return 0;
 }
diff --git a/libcxx/test/std/strings/basic.string/string.cons/string_view.pass.cpp b/libcxx/test/std/strings/basic.string/string.cons/string_view.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.cons/string_view.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.cons/string_view.pass.cpp
@@ -21,12 +21,10 @@
 #include "min_allocator.h"
 
 template <class charT>
-void
-test(std::basic_string_view<charT> sv)
-{
-    typedef std::basic_string<charT, std::char_traits<charT>, test_allocator<charT> > S;
-    typedef typename S::traits_type T;
-    typedef typename S::allocator_type A;
+TEST_CONSTEXPR_CXX20 void test(std::basic_string_view<charT> sv) {
+  typedef std::basic_string<charT, std::char_traits<charT>, test_allocator<charT> > S;
+  typedef typename S::traits_type T;
+  typedef typename S::allocator_type A;
   {
     S s2(sv);
     LIBCPP_ASSERT(s2.__invariants());
@@ -47,11 +45,9 @@
 }
 
 template <class charT, class A>
-void
-test(std::basic_string_view<charT> sv, const A& a)
-{
-    typedef std::basic_string<charT, std::char_traits<charT>, A> S;
-    typedef typename S::traits_type T;
+TEST_CONSTEXPR_CXX20 void test(std::basic_string_view<charT> sv, const A& a) {
+  typedef std::basic_string<charT, std::char_traits<charT>, A> S;
+  typedef typename S::traits_type T;
   {
     S s2(sv, a);
     LIBCPP_ASSERT(s2.__invariants());
@@ -71,9 +67,9 @@
   }
 }
 
-int main(int, char**)
-{
-    {
+TEST_CONSTEXPR_CXX20
+bool test() {
+  {
     typedef test_allocator<char> A;
     typedef std::basic_string_view<char, std::char_traits<char> > SV;
 
@@ -108,5 +104,14 @@
     }
 #endif
 
+    return true;
+}
+
+int main(int, char**) {
+  test();
+#if TEST_STD_VER > 17
+  static_assert(test());
+#endif
+
   return 0;
 }
diff --git a/libcxx/test/std/strings/basic.string/string.cons/string_view_assignment.pass.cpp b/libcxx/test/std/strings/basic.string/string.cons/string_view_assignment.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.cons/string_view_assignment.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.cons/string_view_assignment.pass.cpp
@@ -17,20 +17,18 @@
 #include "min_allocator.h"
 
 template <class S, class SV>
-void
-test(S s1, SV sv)
-{
-    typedef typename S::traits_type T;
-    s1 = sv;
-    LIBCPP_ASSERT(s1.__invariants());
-    assert(s1.size() == sv.size());
-    assert(T::compare(s1.data(), sv.data(), s1.size()) == 0);
-    assert(s1.capacity() >= s1.size());
+TEST_CONSTEXPR_CXX20 void test(S s1, SV sv) {
+  typedef typename S::traits_type T;
+  s1 = sv;
+  LIBCPP_ASSERT(s1.__invariants());
+  assert(s1.size() == sv.size());
+  assert(T::compare(s1.data(), sv.data(), s1.size()) == 0);
+  assert(s1.capacity() >= s1.size());
 }
 
-int main(int, char**)
-{
-    {
+TEST_CONSTEXPR_CXX20
+bool test() {
+  {
     typedef std::string S;
     typedef std::string_view SV;
     test(S(), SV(""));
@@ -48,7 +46,7 @@
     test(S("1234567890123456789012345678901234567890123456789012345678901234567890"
            "1234567890123456789012345678901234567890123456789012345678901234567890"),
          SV("abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz"));
-    }
+  }
 #if TEST_STD_VER >= 11
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
@@ -71,5 +69,14 @@
     }
 #endif
 
+    return true;
+}
+
+int main(int, char**) {
+  test();
+#if TEST_STD_VER > 17
+  static_assert(test());
+#endif
+
   return 0;
 }
diff --git a/libcxx/test/std/strings/basic.string/string.cons/substr.pass.cpp b/libcxx/test/std/strings/basic.string/string.cons/substr.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.cons/substr.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.cons/substr.pass.cpp
@@ -28,121 +28,100 @@
 #include "min_allocator.h"
 
 template <class S>
-void
-test(S str, unsigned pos)
-{
-    typedef typename S::traits_type T;
-    typedef typename S::allocator_type A;
-
-    if (pos <= str.size())
-    {
-        S s2(str, pos);
-        LIBCPP_ASSERT(s2.__invariants());
-        typename S::size_type rlen = str.size() - pos;
-        assert(s2.size() == rlen);
-        assert(T::compare(s2.data(), str.data() + pos, rlen) == 0);
-        assert(s2.get_allocator() == A());
-        assert(s2.capacity() >= s2.size());
-    }
+TEST_CONSTEXPR_CXX20 void test(S str, unsigned pos) {
+  typedef typename S::traits_type T;
+  typedef typename S::allocator_type A;
+
+  if (pos <= str.size()) {
+    S s2(str, pos);
+    LIBCPP_ASSERT(s2.__invariants());
+    typename S::size_type rlen = str.size() - pos;
+    assert(s2.size() == rlen);
+    assert(T::compare(s2.data(), str.data() + pos, rlen) == 0);
+    assert(s2.get_allocator() == A());
+    assert(s2.capacity() >= s2.size());
+  }
 #ifndef TEST_HAS_NO_EXCEPTIONS
-    else
-    {
-        try
-        {
-            S s2(str, pos);
-            assert(false);
-        }
-        catch (std::out_of_range&)
-        {
-            assert(pos > str.size());
-        }
+  else if (!TEST_IS_CONSTANT_EVALUATED) {
+    try {
+      S s2(str, pos);
+      assert(false);
+    } catch (std::out_of_range&) {
+      assert(pos > str.size());
     }
+  }
 #endif
 }
 
 template <class S>
-void
-test(S str, unsigned pos, unsigned n)
-{
-    typedef typename S::traits_type T;
-    typedef typename S::allocator_type A;
-    if (pos <= str.size())
-    {
-        S s2(str, pos, n);
-        LIBCPP_ASSERT(s2.__invariants());
-        typename S::size_type rlen = std::min<typename S::size_type>(str.size() - pos, n);
-        assert(s2.size() == rlen);
-        assert(T::compare(s2.data(), str.data() + pos, rlen) == 0);
-        assert(s2.get_allocator() == A());
-        assert(s2.capacity() >= s2.size());
-    }
+TEST_CONSTEXPR_CXX20 void test(S str, unsigned pos, unsigned n) {
+  typedef typename S::traits_type T;
+  typedef typename S::allocator_type A;
+  if (pos <= str.size()) {
+    S s2(str, pos, n);
+    LIBCPP_ASSERT(s2.__invariants());
+    typename S::size_type rlen = std::min<typename S::size_type>(str.size() - pos, n);
+    assert(s2.size() == rlen);
+    assert(T::compare(s2.data(), str.data() + pos, rlen) == 0);
+    assert(s2.get_allocator() == A());
+    assert(s2.capacity() >= s2.size());
+  }
 #ifndef TEST_HAS_NO_EXCEPTIONS
-    else
-    {
-        try
-        {
-            S s2(str, pos, n);
-            assert(false);
-        }
-        catch (std::out_of_range&)
-        {
-            assert(pos > str.size());
-        }
+  else if (!TEST_IS_CONSTANT_EVALUATED) {
+    try {
+      S s2(str, pos, n);
+      assert(false);
+    } catch (std::out_of_range&) {
+      assert(pos > str.size());
     }
+  }
 #endif
 }
 
 template <class S>
-void
-test(S str, unsigned pos, unsigned n, const typename S::allocator_type& a)
-{
-    typedef typename S::traits_type T;
-
-    if (pos <= str.size())
-    {
-        S s2(str, pos, n, a);
-        LIBCPP_ASSERT(s2.__invariants());
-        typename S::size_type rlen = std::min<typename S::size_type>(str.size() - pos, n);
-        assert(s2.size() == rlen);
-        assert(T::compare(s2.data(), str.data() + pos, rlen) == 0);
-        assert(s2.get_allocator() == a);
-        assert(s2.capacity() >= s2.size());
-    }
+TEST_CONSTEXPR_CXX20 void test(S str, unsigned pos, unsigned n, const typename S::allocator_type& a) {
+  typedef typename S::traits_type T;
+
+  if (pos <= str.size()) {
+    S s2(str, pos, n, a);
+    LIBCPP_ASSERT(s2.__invariants());
+    typename S::size_type rlen = std::min<typename S::size_type>(str.size() - pos, n);
+    assert(s2.size() == rlen);
+    assert(T::compare(s2.data(), str.data() + pos, rlen) == 0);
+    assert(s2.get_allocator() == a);
+    assert(s2.capacity() >= s2.size());
+  }
 #ifndef TEST_HAS_NO_EXCEPTIONS
-    else
-    {
-        try
-        {
-            S s2(str, pos, n, a);
-            assert(false);
-        }
-        catch (std::out_of_range&)
-        {
-            assert(pos > str.size());
-        }
+  else if (!TEST_IS_CONSTANT_EVALUATED) {
+    try {
+      S s2(str, pos, n, a);
+      assert(false);
+    } catch (std::out_of_range&) {
+      assert(pos > str.size());
     }
+  }
 #endif
 }
 
 #if TEST_STD_VER >= 11
-#ifndef TEST_HAS_NO_EXCEPTIONS
-void test2583()
-{   // LWG #2583
-    typedef std::basic_string<char, std::char_traits<char>, test_allocator<char> > StringA;
-    std::vector<StringA, std::scoped_allocator_adaptor<test_allocator<StringA>>> vs;
-    StringA s{"1234"};
-    vs.emplace_back(s, 2);
-
-    try { vs.emplace_back(s, 5); }
-    catch (const std::out_of_range&) { return; }
-    assert(false);
+void test2583() { // LWG #2583
+  typedef std::basic_string<char, std::char_traits<char>, test_allocator<char> > StringA;
+  std::vector<StringA, std::scoped_allocator_adaptor<test_allocator<StringA> > > vs;
+  StringA s{"1234"};
+  vs.emplace_back(s, 2);
+
+  try {
+    vs.emplace_back(s, 5);
+  } catch (const std::out_of_range&) {
+    return;
+  }
+  assert(false);
 }
 #endif
-#endif
 
-int main(int, char**)
-{
-    {
+TEST_CONSTEXPR_CXX20
+bool test() {
+  {
     typedef test_allocator<char> A;
     typedef std::basic_string<char, std::char_traits<char>, A> S;
 
@@ -179,9 +158,9 @@
     test(S("1234567890123456789012345678901234567890123456789012345678901234567890", A(7)), 50, 1, A(8));
     test(S("1234567890123456789012345678901234567890123456789012345678901234567890", A(7)), 50, 10, A(8));
     test(S("1234567890123456789012345678901234567890123456789012345678901234567890", A(7)), 50, 100, A(8));
-    }
+  }
 #if TEST_STD_VER >= 11
-    {
+  {
     typedef min_allocator<char> A;
     typedef std::basic_string<char, std::char_traits<char>, A> S;
 
@@ -218,11 +197,19 @@
     test(S("1234567890123456789012345678901234567890123456789012345678901234567890", A()), 50, 1, A());
     test(S("1234567890123456789012345678901234567890123456789012345678901234567890", A()), 50, 10, A());
     test(S("1234567890123456789012345678901234567890123456789012345678901234567890", A()), 50, 100, A());
-    }
+  }
 
-#ifndef TEST_HAS_NO_EXCEPTIONS
+  if (!TEST_IS_CONSTANT_EVALUATED)
     test2583();
 #endif
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+#if TEST_STD_VER > 17
+  static_assert(test());
 #endif
 
   return 0;
diff --git a/libcxx/test/std/strings/basic.string/string.contains/contains.char.pass.cpp b/libcxx/test/std/strings/basic.string/string.contains/contains.char.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.contains/contains.char.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.contains/contains.char.pass.cpp
@@ -16,26 +16,28 @@
 
 #include "test_macros.h"
 
-void test()
-{
-    using S = std::string;
+constexpr bool test() {
+  using S = std::string;
 
-    S s1 {};
-    S s2 {"abcde", 5};
+  S s1{};
+  S s2{"abcde", 5};
 
-    ASSERT_NOEXCEPT(s1.contains('e'));
+  ASSERT_NOEXCEPT(s1.contains('e'));
 
-    assert(!s1.contains('c'));
-    assert(!s1.contains('e'));
-    assert(!s1.contains('x'));
-    assert( s2.contains('c'));
-    assert( s2.contains('e'));
-    assert(!s2.contains('x'));
+  assert(!s1.contains('c'));
+  assert(!s1.contains('e'));
+  assert(!s1.contains('x'));
+  assert(s2.contains('c'));
+  assert(s2.contains('e'));
+  assert(!s2.contains('x'));
+
+  return true;
 }
 
-int main(int, char**)
-{
-    test();
+int main(int, char**) {
+
+  test();
+  static_assert(test());
 
-    return 0;
+  return 0;
 }
diff --git a/libcxx/test/std/strings/basic.string/string.contains/contains.ptr.pass.cpp b/libcxx/test/std/strings/basic.string/string.contains/contains.ptr.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.contains/contains.ptr.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.contains/contains.ptr.pass.cpp
@@ -16,56 +16,58 @@
 
 #include "test_macros.h"
 
-void test()
-{
-    using S = std::string;
+constexpr bool test() {
+  using S = std::string;
 
-    const char* s = "abcde";
-    S s0;
-    S s1 {s + 4, 1};
-    S s3 {s + 2, 3};
-    S sNot {"xyz", 3};
+  const char* s = "abcde";
+  S s0;
+  S s1{s + 4, 1};
+  S s3{s + 2, 3};
+  S sNot{"xyz", 3};
 
-    assert(s0.contains(""));
-    assert(!s0.contains("e"));
+  assert(s0.contains(""));
+  assert(!s0.contains("e"));
 
-    assert( s1.contains(""));
-    assert(!s1.contains("d"));
-    assert( s1.contains("e"));
-    assert(!s1.contains("de"));
-    assert(!s1.contains("cd"));
-    assert(!s1.contains("cde"));
-    assert(!s1.contains("bcde"));
-    assert(!s1.contains("abcde"));
-    assert(!s1.contains("xyz"));
+  assert(s1.contains(""));
+  assert(!s1.contains("d"));
+  assert(s1.contains("e"));
+  assert(!s1.contains("de"));
+  assert(!s1.contains("cd"));
+  assert(!s1.contains("cde"));
+  assert(!s1.contains("bcde"));
+  assert(!s1.contains("abcde"));
+  assert(!s1.contains("xyz"));
 
-    assert( s3.contains(""));
-    assert( s3.contains("d"));
-    assert( s3.contains("e"));
-    assert( s3.contains("de"));
-    assert( s3.contains("cd"));
-    assert(!s3.contains("ce"));
-    assert( s3.contains("cde"));
-    assert(!s3.contains("edc"));
-    assert(!s3.contains("bcde"));
-    assert(!s3.contains("abcde"));
-    assert(!s3.contains("xyz"));
+  assert(s3.contains(""));
+  assert(s3.contains("d"));
+  assert(s3.contains("e"));
+  assert(s3.contains("de"));
+  assert(s3.contains("cd"));
+  assert(!s3.contains("ce"));
+  assert(s3.contains("cde"));
+  assert(!s3.contains("edc"));
+  assert(!s3.contains("bcde"));
+  assert(!s3.contains("abcde"));
+  assert(!s3.contains("xyz"));
 
-    assert( sNot.contains(""));
-    assert(!sNot.contains("d"));
-    assert(!sNot.contains("e"));
-    assert(!sNot.contains("de"));
-    assert(!sNot.contains("cd"));
-    assert(!sNot.contains("cde"));
-    assert(!sNot.contains("bcde"));
-    assert(!sNot.contains("abcde"));
-    assert( sNot.contains("xyz"));
-    assert(!sNot.contains("zyx"));
+  assert(sNot.contains(""));
+  assert(!sNot.contains("d"));
+  assert(!sNot.contains("e"));
+  assert(!sNot.contains("de"));
+  assert(!sNot.contains("cd"));
+  assert(!sNot.contains("cde"));
+  assert(!sNot.contains("bcde"));
+  assert(!sNot.contains("abcde"));
+  assert(sNot.contains("xyz"));
+  assert(!sNot.contains("zyx"));
+
+  return true;
 }
 
-int main(int, char**)
-{
-    test();
+int main(int, char**) {
+
+  test();
+  static_assert(test());
 
-    return 0;
+  return 0;
 }
diff --git a/libcxx/test/std/strings/basic.string/string.contains/contains.string_view.pass.cpp b/libcxx/test/std/strings/basic.string/string.contains/contains.string_view.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.contains/contains.string_view.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.contains/contains.string_view.pass.cpp
@@ -16,77 +16,79 @@
 
 #include "test_macros.h"
 
-void test()
-{
-    using S = std::string;
-    using SV = std::string_view;
-
-    const char* s = "abcde";
-    S s0;
-    S s1 {s + 1, 1};
-    S s3 {s + 1, 3};
-    S s5 {s    , 5};
-    S sNot {"xyz", 3};
-
-    SV sv0;
-    SV sv1 {s + 1, 1};
-    SV sv2 {s + 1, 2};
-    SV sv3 {s + 1, 3};
-    SV sv4 {s + 1, 4};
-    SV sv5 {s    , 5};
-    SV svNot  {"xyz", 3};
-    SV svNot2 {"bd" , 2};
-    SV svNot3 {"dcb", 3};
-
-    ASSERT_NOEXCEPT(s0.contains(sv0));
-
-    assert( s0.contains(sv0));
-    assert(!s0.contains(sv1));
-
-    assert( s1.contains(sv0));
-    assert( s1.contains(sv1));
-    assert(!s1.contains(sv2));
-    assert(!s1.contains(sv3));
-    assert(!s1.contains(sv4));
-    assert(!s1.contains(sv5));
-    assert(!s1.contains(svNot));
-    assert(!s1.contains(svNot2));
-    assert(!s1.contains(svNot3));
-
-    assert( s3.contains(sv0));
-    assert( s3.contains(sv1));
-    assert( s3.contains(sv2));
-    assert( s3.contains(sv3));
-    assert(!s3.contains(sv4));
-    assert(!s3.contains(sv5));
-    assert(!s3.contains(svNot));
-    assert(!s3.contains(svNot2));
-    assert(!s3.contains(svNot3));
-
-    assert( s5.contains(sv0));
-    assert( s5.contains(sv1));
-    assert( s5.contains(sv2));
-    assert( s5.contains(sv3));
-    assert( s5.contains(sv4));
-    assert( s5.contains(sv5));
-    assert(!s5.contains(svNot));
-    assert(!s5.contains(svNot2));
-    assert(!s5.contains(svNot3));
-
-    assert( sNot.contains(sv0));
-    assert(!sNot.contains(sv1));
-    assert(!sNot.contains(sv2));
-    assert(!sNot.contains(sv3));
-    assert(!sNot.contains(sv4));
-    assert(!sNot.contains(sv5));
-    assert( sNot.contains(svNot));
-    assert(!sNot.contains(svNot2));
-    assert(!sNot.contains(svNot3));
+constexpr bool test() {
+  using S = std::string;
+  using SV = std::string_view;
+
+  const char* s = "abcde";
+  S s0;
+  S s1{s + 1, 1};
+  S s3{s + 1, 3};
+  S s5{s, 5};
+  S sNot{"xyz", 3};
+
+  SV sv0;
+  SV sv1{s + 1, 1};
+  SV sv2{s + 1, 2};
+  SV sv3{s + 1, 3};
+  SV sv4{s + 1, 4};
+  SV sv5{s, 5};
+  SV svNot{"xyz", 3};
+  SV svNot2{"bd", 2};
+  SV svNot3{"dcb", 3};
+
+  ASSERT_NOEXCEPT(s0.contains(sv0));
+
+  assert(s0.contains(sv0));
+  assert(!s0.contains(sv1));
+
+  assert(s1.contains(sv0));
+  assert(s1.contains(sv1));
+  assert(!s1.contains(sv2));
+  assert(!s1.contains(sv3));
+  assert(!s1.contains(sv4));
+  assert(!s1.contains(sv5));
+  assert(!s1.contains(svNot));
+  assert(!s1.contains(svNot2));
+  assert(!s1.contains(svNot3));
+
+  assert(s3.contains(sv0));
+  assert(s3.contains(sv1));
+  assert(s3.contains(sv2));
+  assert(s3.contains(sv3));
+  assert(!s3.contains(sv4));
+  assert(!s3.contains(sv5));
+  assert(!s3.contains(svNot));
+  assert(!s3.contains(svNot2));
+  assert(!s3.contains(svNot3));
+
+  assert(s5.contains(sv0));
+  assert(s5.contains(sv1));
+  assert(s5.contains(sv2));
+  assert(s5.contains(sv3));
+  assert(s5.contains(sv4));
+  assert(s5.contains(sv5));
+  assert(!s5.contains(svNot));
+  assert(!s5.contains(svNot2));
+  assert(!s5.contains(svNot3));
+
+  assert(sNot.contains(sv0));
+  assert(!sNot.contains(sv1));
+  assert(!sNot.contains(sv2));
+  assert(!sNot.contains(sv3));
+  assert(!sNot.contains(sv4));
+  assert(!sNot.contains(sv5));
+  assert(sNot.contains(svNot));
+  assert(!sNot.contains(svNot2));
+  assert(!sNot.contains(svNot3));
+
+  return true;
 }
 
-int main(int, char**)
-{
-    test();
+int main(int, char**) {
+
+  test();
+  static_assert(test());
 
-    return 0;
+  return 0;
 }
diff --git a/libcxx/test/std/strings/basic.string/string.ends_with/ends_with.char.pass.cpp b/libcxx/test/std/strings/basic.string/string.ends_with/ends_with.char.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.ends_with/ends_with.char.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.ends_with/ends_with.char.pass.cpp
@@ -16,9 +16,8 @@
 
 #include "test_macros.h"
 
-int main(int, char**)
-{
-    {
+constexpr bool test() {
+  {
     typedef std::string S;
     S  s1 {};
     S  s2 { "abcde", 5 };
@@ -29,7 +28,15 @@
     assert (!s1.ends_with('x'));
     assert ( s2.ends_with('e'));
     assert (!s2.ends_with('x'));
-    }
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+
+  test();
+  static_assert(test());
 
   return 0;
 }
diff --git a/libcxx/test/std/strings/basic.string/string.ends_with/ends_with.ptr.pass.cpp b/libcxx/test/std/strings/basic.string/string.ends_with/ends_with.ptr.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.ends_with/ends_with.ptr.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.ends_with/ends_with.ptr.pass.cpp
@@ -16,9 +16,8 @@
 
 #include "test_macros.h"
 
-int main(int, char**)
-{
-    {
+constexpr bool test() {
+  {
     typedef std::string S;
     const char *s = "abcde";
 
@@ -58,7 +57,15 @@
     assert (!sNot.ends_with("bcde"));
     assert (!sNot.ends_with("abcde"));
     assert ( sNot.ends_with("def"));
-    }
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+
+  test();
+  static_assert(test());
 
   return 0;
 }
diff --git a/libcxx/test/std/strings/basic.string/string.ends_with/ends_with.string_view.pass.cpp b/libcxx/test/std/strings/basic.string/string.ends_with/ends_with.string_view.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.ends_with/ends_with.string_view.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.ends_with/ends_with.string_view.pass.cpp
@@ -16,9 +16,8 @@
 
 #include "test_macros.h"
 
-int main(int, char**)
-{
-    {
+constexpr bool test() {
+  {
     typedef std::string S;
     typedef std::string_view SV;
     const char *s = "abcde";
@@ -67,7 +66,15 @@
     assert (!sNot.ends_with(sv4));
     assert (!sNot.ends_with(sv5));
     assert ( sNot.ends_with(svNot));
-    }
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+
+  test();
+  static_assert(test());
 
   return 0;
 }
diff --git a/libcxx/test/std/strings/basic.string/string.iterators/begin.pass.cpp b/libcxx/test/std/strings/basic.string/string.iterators/begin.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.iterators/begin.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.iterators/begin.pass.cpp
@@ -18,22 +18,19 @@
 #include "min_allocator.h"
 
 template <class S>
-void
-test(S s)
-{
-    const S& cs = s;
-    typename S::iterator b = s.begin();
-    typename S::const_iterator cb = cs.begin();
-    if (!s.empty())
-    {
-        assert(*b == s[0]);
-    }
-    assert(b == cb);
+TEST_CONSTEXPR_CXX20 void test(S s) {
+  const S& cs = s;
+  typename S::iterator b = s.begin();
+  typename S::const_iterator cb = cs.begin();
+  if (!s.empty()) {
+    assert(*b == s[0]);
+  }
+  assert(b == cb);
 }
 
-int main(int, char**)
-{
-    {
+TEST_CONSTEXPR_CXX20
+bool test() {
+  {
     typedef std::string S;
     test(S());
     test(S("123"));
@@ -46,5 +43,14 @@
     }
 #endif
 
+    return true;
+}
+
+int main(int, char**) {
+  test();
+#if TEST_STD_VER > 17
+  static_assert(test());
+#endif
+
   return 0;
 }
diff --git a/libcxx/test/std/strings/basic.string/string.iterators/cbegin.pass.cpp b/libcxx/test/std/strings/basic.string/string.iterators/cbegin.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.iterators/cbegin.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.iterators/cbegin.pass.cpp
@@ -17,20 +17,17 @@
 #include "min_allocator.h"
 
 template <class S>
-void
-test(const S& s)
-{
-    typename S::const_iterator cb = s.cbegin();
-    if (!s.empty())
-    {
-        assert(*cb == s[0]);
-    }
-    assert(cb == s.begin());
+TEST_CONSTEXPR_CXX20 void test(const S& s) {
+  typename S::const_iterator cb = s.cbegin();
+  if (!s.empty()) {
+    assert(*cb == s[0]);
+  }
+  assert(cb == s.begin());
 }
 
-int main(int, char**)
-{
-    {
+TEST_CONSTEXPR_CXX20
+bool test() {
+  {
     typedef std::string S;
     test(S());
     test(S("123"));
@@ -43,5 +40,14 @@
     }
 #endif
 
+    return true;
+}
+
+int main(int, char**) {
+  test();
+#if TEST_STD_VER > 17
+  static_assert(test());
+#endif
+
   return 0;
 }
diff --git a/libcxx/test/std/strings/basic.string/string.iterators/cend.pass.cpp b/libcxx/test/std/strings/basic.string/string.iterators/cend.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.iterators/cend.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.iterators/cend.pass.cpp
@@ -17,16 +17,14 @@
 #include "min_allocator.h"
 
 template <class S>
-void
-test(const S& s)
-{
-    typename S::const_iterator ce = s.cend();
-    assert(ce == s.end());
+TEST_CONSTEXPR_CXX20 void test(const S& s) {
+  typename S::const_iterator ce = s.cend();
+  assert(ce == s.end());
 }
 
-int main(int, char**)
-{
-    {
+TEST_CONSTEXPR_CXX20
+bool test() {
+  {
     typedef std::string S;
     test(S());
     test(S("123"));
@@ -39,5 +37,14 @@
     }
 #endif
 
+    return true;
+}
+
+int main(int, char**) {
+  test();
+#if TEST_STD_VER > 17
+  static_assert(test());
+#endif
+
   return 0;
 }
diff --git a/libcxx/test/std/strings/basic.string/string.iterators/crbegin.pass.cpp b/libcxx/test/std/strings/basic.string/string.iterators/crbegin.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.iterators/crbegin.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.iterators/crbegin.pass.cpp
@@ -17,20 +17,17 @@
 #include "min_allocator.h"
 
 template <class S>
-void
-test(const S& s)
-{
-    typename S::const_reverse_iterator cb = s.crbegin();
-    if (!s.empty())
-    {
-        assert(*cb == s.back());
-    }
-    assert(cb == s.rbegin());
+TEST_CONSTEXPR_CXX20 void test(const S& s) {
+  typename S::const_reverse_iterator cb = s.crbegin();
+  if (!s.empty()) {
+    assert(*cb == s.back());
+  }
+  assert(cb == s.rbegin());
 }
 
-int main(int, char**)
-{
-    {
+TEST_CONSTEXPR_CXX20
+bool test() {
+  {
     typedef std::string S;
     test(S());
     test(S("123"));
@@ -43,5 +40,14 @@
     }
 #endif
 
+    return true;
+}
+
+int main(int, char**) {
+  test();
+#if TEST_STD_VER > 17
+  static_assert(test());
+#endif
+
   return 0;
 }
diff --git a/libcxx/test/std/strings/basic.string/string.iterators/crend.pass.cpp b/libcxx/test/std/strings/basic.string/string.iterators/crend.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.iterators/crend.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.iterators/crend.pass.cpp
@@ -17,16 +17,14 @@
 #include "min_allocator.h"
 
 template <class S>
-void
-test(const S& s)
-{
-    typename S::const_reverse_iterator ce = s.crend();
-    assert(ce == s.rend());
+TEST_CONSTEXPR_CXX20 void test(const S& s) {
+  typename S::const_reverse_iterator ce = s.crend();
+  assert(ce == s.rend());
 }
 
-int main(int, char**)
-{
-    {
+TEST_CONSTEXPR_CXX20
+bool test() {
+  {
     typedef std::string S;
     test(S());
     test(S("123"));
@@ -39,5 +37,14 @@
     }
 #endif
 
+    return true;
+}
+
+int main(int, char**) {
+  test();
+#if TEST_STD_VER > 17
+  static_assert(test());
+#endif
+
   return 0;
 }
diff --git a/libcxx/test/std/strings/basic.string/string.iterators/end.pass.cpp b/libcxx/test/std/strings/basic.string/string.iterators/end.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.iterators/end.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.iterators/end.pass.cpp
@@ -19,24 +19,21 @@
 #include "min_allocator.h"
 
 template <class S>
-void
-test(S s)
-{
-    const S& cs = s;
-    typename S::iterator e = s.end();
-    typename S::const_iterator ce = cs.end();
-    if (s.empty())
-    {
-        assert(e == s.begin());
-        assert(ce == cs.begin());
-    }
-    assert(static_cast<std::size_t>(e - s.begin()) == s.size());
-    assert(static_cast<std::size_t>(ce - cs.begin()) == cs.size());
+TEST_CONSTEXPR_CXX20 void test(S s) {
+  const S& cs = s;
+  typename S::iterator e = s.end();
+  typename S::const_iterator ce = cs.end();
+  if (s.empty()) {
+    assert(e == s.begin());
+    assert(ce == cs.begin());
+  }
+  assert(static_cast<std::size_t>(e - s.begin()) == s.size());
+  assert(static_cast<std::size_t>(ce - cs.begin()) == cs.size());
 }
 
-int main(int, char**)
-{
-    {
+TEST_CONSTEXPR_CXX20
+bool test() {
+  {
     typedef std::string S;
     test(S());
     test(S("123"));
@@ -49,5 +46,14 @@
     }
 #endif
 
+    return true;
+}
+
+int main(int, char**) {
+  test();
+#if TEST_STD_VER > 17
+  static_assert(test());
+#endif
+
   return 0;
 }
diff --git a/libcxx/test/std/strings/basic.string/string.iterators/iterators.pass.cpp b/libcxx/test/std/strings/basic.string/string.iterators/iterators.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.iterators/iterators.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.iterators/iterators.pass.cpp
@@ -22,40 +22,38 @@
 
 #include "test_macros.h"
 
-template<class C>
-void test()
-{
-    { // N3644 testing
-        typename C::iterator ii1{}, ii2{};
-        typename C::iterator ii4 = ii1;
-        typename C::const_iterator cii{};
-        assert ( ii1 == ii2 );
-        assert ( ii1 == ii4 );
+template <class C>
+TEST_CONSTEXPR_CXX20 void test() {
+  { // N3644 testing
+    typename C::iterator ii1{}, ii2{};
+    typename C::iterator ii4 = ii1;
+    typename C::const_iterator cii{};
+    assert(ii1 == ii2);
+    assert(ii1 == ii4);
 
-        assert (!(ii1 != ii2 ));
+    assert(!(ii1 != ii2));
 
-        assert ( (ii1 == cii ));
-        assert ( (cii == ii1 ));
-        assert (!(ii1 != cii ));
-        assert (!(cii != ii1 ));
-        assert (!(ii1 <  cii ));
-        assert (!(cii <  ii1 ));
-        assert ( (ii1 <= cii ));
-        assert ( (cii <= ii1 ));
-        assert (!(ii1 >  cii ));
-        assert (!(cii >  ii1 ));
-        assert ( (ii1 >= cii ));
-        assert ( (cii >= ii1 ));
-        assert (cii - ii1 == 0);
-        assert (ii1 - cii == 0);
-    }
+    assert((ii1 == cii));
+    assert((cii == ii1));
+    assert(!(ii1 != cii));
+    assert(!(cii != ii1));
+    assert(!(ii1 < cii));
+    assert(!(cii < ii1));
+    assert((ii1 <= cii));
+    assert((cii <= ii1));
+    assert(!(ii1 > cii));
+    assert(!(cii > ii1));
+    assert((ii1 >= cii));
+    assert((cii >= ii1));
+    assert(cii - ii1 == 0);
+    assert(ii1 - cii == 0);
+  }
 }
 
-int main(int, char**)
-{
-    test<std::string>();
+TEST_CONSTEXPR_CXX20 bool test() {
+  test<std::string>();
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
-    test<std::wstring>();
+  test<std::wstring>();
 #endif
 
 #if defined(__cpp_lib_char8_t) && __cpp_lib_char8_t >= 201811L
@@ -65,5 +63,14 @@
     test<std::u16string>();
     test<std::u32string>();
 
-    return 0;
+    return true;
+}
+
+int main(int, char**) {
+  test();
+#if TEST_STD_VER > 17
+  static_assert(test());
+#endif
+
+  return 0;
 }
diff --git a/libcxx/test/std/strings/basic.string/string.iterators/rbegin.pass.cpp b/libcxx/test/std/strings/basic.string/string.iterators/rbegin.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.iterators/rbegin.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.iterators/rbegin.pass.cpp
@@ -18,22 +18,19 @@
 #include "min_allocator.h"
 
 template <class S>
-void
-test(S s)
-{
-    const S& cs = s;
-    typename S::reverse_iterator b = s.rbegin();
-    typename S::const_reverse_iterator cb = cs.rbegin();
-    if (!s.empty())
-    {
-        assert(*b == s.back());
-    }
-    assert(b == cb);
+TEST_CONSTEXPR_CXX20 void test(S s) {
+  const S& cs = s;
+  typename S::reverse_iterator b = s.rbegin();
+  typename S::const_reverse_iterator cb = cs.rbegin();
+  if (!s.empty()) {
+    assert(*b == s.back());
+  }
+  assert(b == cb);
 }
 
-int main(int, char**)
-{
-    {
+TEST_CONSTEXPR_CXX20
+bool test() {
+  {
     typedef std::string S;
     test(S());
     test(S("123"));
@@ -46,5 +43,14 @@
     }
 #endif
 
+    return true;
+}
+
+int main(int, char**) {
+  test();
+#if TEST_STD_VER > 17
+  static_assert(test());
+#endif
+
   return 0;
 }
diff --git a/libcxx/test/std/strings/basic.string/string.iterators/rend.pass.cpp b/libcxx/test/std/strings/basic.string/string.iterators/rend.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.iterators/rend.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.iterators/rend.pass.cpp
@@ -19,24 +19,21 @@
 #include "min_allocator.h"
 
 template <class S>
-void
-test(S s)
-{
-    const S& cs = s;
-    typename S::reverse_iterator e = s.rend();
-    typename S::const_reverse_iterator ce = cs.rend();
-    if (s.empty())
-    {
-        assert(e == s.rbegin());
-        assert(ce == cs.rbegin());
-    }
-    assert(static_cast<std::size_t>(e - s.rbegin()) == s.size());
-    assert(static_cast<std::size_t>(ce - cs.rbegin()) == cs.size());
+TEST_CONSTEXPR_CXX20 void test(S s) {
+  const S& cs = s;
+  typename S::reverse_iterator e = s.rend();
+  typename S::const_reverse_iterator ce = cs.rend();
+  if (s.empty()) {
+    assert(e == s.rbegin());
+    assert(ce == cs.rbegin());
+  }
+  assert(static_cast<std::size_t>(e - s.rbegin()) == s.size());
+  assert(static_cast<std::size_t>(ce - cs.rbegin()) == cs.size());
 }
 
-int main(int, char**)
-{
-    {
+TEST_CONSTEXPR_CXX20
+bool test() {
+  {
     typedef std::string S;
     test(S());
     test(S("123"));
@@ -49,5 +46,14 @@
     }
 #endif
 
+    return true;
+}
+
+int main(int, char**) {
+  test();
+#if TEST_STD_VER > 17
+  static_assert(test());
+#endif
+
   return 0;
 }
diff --git a/libcxx/test/std/strings/basic.string/string.modifiers/robust_against_adl.pass.cpp b/libcxx/test/std/strings/basic.string/string.modifiers/robust_against_adl.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.modifiers/robust_against_adl.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.modifiers/robust_against_adl.pass.cpp
@@ -11,25 +11,35 @@
 #include <cassert>
 #include <string>
 
+#include "test_macros.h"
+
 struct Incomplete;
 template<class T> struct Holder { T t; };
 
 template<class T>
 struct Charlike {
-    char ch_;
-    Charlike(char ch) : ch_(ch) {}
-    operator char() const { return ch_; }
+  char ch_;
+  TEST_CONSTEXPR Charlike(char ch) : ch_(ch) {}
+  TEST_CONSTEXPR operator char() const { return ch_; }
 };
 
-int main(int, char**)
-{
-    std::string s;
-    Charlike<Holder<Incomplete> > a[] = {'m', 'a', 'h', 'i'};
-    s.append(a, a+4);
-    s.assign(a, a+4);
-    s.insert(s.begin(), a, a+4);
-    s.replace(s.begin(), s.begin()+4, a, a+4);
-    assert(s == "mahimahi");
-
-    return 0;
+TEST_CONSTEXPR_CXX20 bool test() {
+  std::string s;
+  Charlike<Holder<Incomplete> > a[] = {'m', 'a', 'h', 'i'};
+  s.append(a, a+4);
+  s.assign(a, a+4);
+  s.insert(s.begin(), a, a+4);
+  s.replace(s.begin(), s.begin()+4, a, a+4);
+  assert(s == "mahimahi");
+
+  return true;
+}
+
+int main() {
+  test();
+#if TEST_STD_VER > 17
+  static_assert(test());
+#endif
+
+  return 0;
 }
diff --git a/libcxx/test/std/strings/basic.string/string.modifiers/string_append/T_size_size.pass.cpp b/libcxx/test/std/strings/basic.string/string.modifiers/string_append/T_size_size.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.modifiers/string_append/T_size_size.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.modifiers/string_append/T_size_size.pass.cpp
@@ -20,7 +20,7 @@
 #include "min_allocator.h"
 
 template <class S, class SV>
-void
+TEST_CONSTEXPR_CXX20 void
 test(S s, SV sv, typename S::size_type pos, typename S::size_type n, S expected)
 {
     if (pos <= sv.size())
@@ -30,7 +30,7 @@
         assert(s == expected);
     }
 #ifndef TEST_HAS_NO_EXCEPTIONS
-    else
+    else if (!TEST_IS_CONSTANT_EVALUATED)
     {
         try
         {
@@ -46,7 +46,7 @@
 }
 
 template <class S, class SV>
-void
+TEST_CONSTEXPR_CXX20 void
 test_npos(S s, SV sv, typename S::size_type pos, S expected)
 {
     if (pos <= sv.size())
@@ -56,7 +56,7 @@
         assert(s == expected);
     }
 #ifndef TEST_HAS_NO_EXCEPTIONS
-    else
+    else if (!TEST_IS_CONSTANT_EVALUATED)
     {
         try
         {
@@ -71,7 +71,8 @@
 #endif
 }
 
-int main(int, char**)
+TEST_CONSTEXPR_CXX20
+bool test()
 {
     {
     typedef std::string S;
@@ -196,6 +197,14 @@
     s.append(sv, 0, std::string::npos);
     assert(s == "ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZ");
     }
+    return true;
+}
+
+int main(int, char**) {
+  test();
+#if TEST_STD_VER > 17
+  static_assert(test());
+#endif
 
   return 0;
 }
diff --git a/libcxx/test/std/strings/basic.string/string.modifiers/string_append/initializer_list.pass.cpp b/libcxx/test/std/strings/basic.string/string.modifiers/string_append/initializer_list.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.modifiers/string_append/initializer_list.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.modifiers/string_append/initializer_list.pass.cpp
@@ -18,7 +18,8 @@
 #include "test_macros.h"
 #include "min_allocator.h"
 
-int main(int, char**)
+TEST_CONSTEXPR_CXX20
+bool test()
 {
     {
         std::string s("123");
@@ -32,5 +33,14 @@
         assert(s == "123abc");
     }
 
+    return true;
+}
+
+int main(int, char**) {
+  test();
+#if TEST_STD_VER > 17
+  static_assert(test());
+#endif
+
   return 0;
 }
diff --git a/libcxx/test/std/strings/basic.string/string.modifiers/string_append/iterator.pass.cpp b/libcxx/test/std/strings/basic.string/string.modifiers/string_append/iterator.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.modifiers/string_append/iterator.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.modifiers/string_append/iterator.pass.cpp
@@ -13,13 +13,14 @@
 
 #include <string>
 #include <cassert>
+#include <bit>
 
 #include "test_macros.h"
 #include "test_iterators.h"
 #include "min_allocator.h"
 
 template <class S, class It>
-void
+TEST_CONSTEXPR_CXX20 void
 test(S s, It first, It last, S expected)
 {
     s.append(first, last);
@@ -52,9 +53,10 @@
 }
 #endif
 
-int main(int, char**)
+TEST_CONSTEXPR_CXX20
+bool test()
 {
-    {
+     {
     typedef std::string S;
     const char* s = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
     test(S(), s, s, S());
@@ -173,7 +175,7 @@
     }
 #endif
 #ifndef TEST_HAS_NO_EXCEPTIONS
-    { // test iterator operations that throw
+    if (!TEST_IS_CONSTANT_EVALUATED) { // test iterator operations that throw
     typedef std::string S;
     typedef ThrowingIterator<char> TIter;
     typedef cpp17_input_iterator<TIter> IIter;
@@ -216,7 +218,7 @@
     assert(s == "ABCD");
     }
 
-    { // regression-test appending to self in sneaky ways
+    if (!TEST_IS_CONSTANT_EVALUATED) { // regression-test appending to self in sneaky ways
     std::string s_short = "hello";
     std::string s_long = "Lorem ipsum dolor sit amet, consectetur/";
     std::string s_othertype = "hello";
@@ -250,5 +252,14 @@
     assert(s == "ABCD");
   }
 
+  return true;
+}
+
+int main(int, char**) {
+  test();
+#if TEST_STD_VER > 17
+  static_assert(test());
+#endif
+
   return 0;
 }
diff --git a/libcxx/test/std/strings/basic.string/string.modifiers/string_append/pointer.pass.cpp b/libcxx/test/std/strings/basic.string/string.modifiers/string_append/pointer.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.modifiers/string_append/pointer.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.modifiers/string_append/pointer.pass.cpp
@@ -18,7 +18,7 @@
 #include "min_allocator.h"
 
 template <class S>
-void
+TEST_CONSTEXPR_CXX20 void
 test(S s, const typename S::value_type* str, S expected)
 {
     s.append(str);
@@ -26,7 +26,8 @@
     assert(s == expected);
 }
 
-int main(int, char**)
+TEST_CONSTEXPR_CXX20
+bool test()
 {
     {
     typedef std::string S;
@@ -77,5 +78,14 @@
     assert(s_long == "Lorem ipsum dolor sit amet, consectetur/Lorem ipsum dolor sit amet, consectetur/");
     }
 
+    return true;
+}
+
+int main(int, char**) {
+  test();
+#if TEST_STD_VER > 17
+  static_assert(test());
+#endif
+
   return 0;
 }
diff --git a/libcxx/test/std/strings/basic.string/string.modifiers/string_append/pointer_size.pass.cpp b/libcxx/test/std/strings/basic.string/string.modifiers/string_append/pointer_size.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.modifiers/string_append/pointer_size.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.modifiers/string_append/pointer_size.pass.cpp
@@ -19,7 +19,7 @@
 #include "min_allocator.h"
 
 template <class S>
-void
+TEST_CONSTEXPR_CXX20 void
 test(S s, const typename S::value_type* str, typename S::size_type n, S expected)
 {
     s.append(str, n);
@@ -27,7 +27,8 @@
     assert(s == expected);
 }
 
-int main(int, char**)
+TEST_CONSTEXPR_CXX20
+bool test()
 {
     {
     typedef std::string S;
@@ -86,5 +87,14 @@
     assert(s_long == "Lorem ipsum dolor sit amet, consectetur/Lorem ipsum dolor sit amet, consectetur/");
     }
 
+    return true;
+}
+
+int main(int, char**) {
+  test();
+#if TEST_STD_VER > 17
+  static_assert(test());
+#endif
+
   return 0;
 }
diff --git a/libcxx/test/std/strings/basic.string/string.modifiers/string_append/push_back.pass.cpp b/libcxx/test/std/strings/basic.string/string.modifiers/string_append/push_back.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.modifiers/string_append/push_back.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.modifiers/string_append/push_back.pass.cpp
@@ -23,7 +23,7 @@
 };
 
 template <class S>
-void
+TEST_CONSTEXPR_CXX20 void
 test(S s, typename S::value_type c, S expected)
 {
     s.push_back(c);
@@ -31,8 +31,7 @@
     assert(s == expected);
 }
 
-int main(int, char**)
-{
+TEST_CONSTEXPR_CXX20 bool test() {
     {
     typedef std::string S;
     test(S(), 'a', S(1, 'a'));
@@ -57,5 +56,14 @@
     s.push_back(vl);
     }
 
+    return true;
+}
+
+int main(int, char**) {
+  test();
+#if TEST_STD_VER > 17
+  static_assert(test());
+#endif
+
   return 0;
 }
diff --git a/libcxx/test/std/strings/basic.string/string.modifiers/string_append/size_char.pass.cpp b/libcxx/test/std/strings/basic.string/string.modifiers/string_append/size_char.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.modifiers/string_append/size_char.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.modifiers/string_append/size_char.pass.cpp
@@ -18,7 +18,7 @@
 #include "min_allocator.h"
 
 template <class S>
-void
+TEST_CONSTEXPR_CXX20 void
 test(S s, typename S::size_type n, typename S::value_type c, S expected)
 {
     s.append(n, c);
@@ -26,7 +26,8 @@
     assert(s == expected);
 }
 
-int main(int, char**)
+TEST_CONSTEXPR_CXX20
+bool test()
 {
     {
     typedef std::string S;
@@ -61,5 +62,14 @@
     }
 #endif
 
+    return true;
+}
+
+int main(int, char**) {
+  test();
+#if TEST_STD_VER > 17
+  static_assert(test());
+#endif
+
   return 0;
 }
diff --git a/libcxx/test/std/strings/basic.string/string.modifiers/string_append/string.pass.cpp b/libcxx/test/std/strings/basic.string/string.modifiers/string_append/string.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.modifiers/string_append/string.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.modifiers/string_append/string.pass.cpp
@@ -18,7 +18,7 @@
 #include "min_allocator.h"
 
 template <class S>
-void
+TEST_CONSTEXPR_CXX20 void
 test(S s, S str, S expected)
 {
     s.append(str);
@@ -26,7 +26,8 @@
     assert(s == expected);
 }
 
-int main(int, char**)
+TEST_CONSTEXPR_CXX20
+bool test()
 {
     {
     typedef std::string S;
@@ -86,5 +87,14 @@
     }
 #endif
 
+    return true;
+}
+
+int main(int, char**) {
+  test();
+#if TEST_STD_VER > 17
+  static_assert(test());
+#endif
+
   return 0;
 }
diff --git a/libcxx/test/std/strings/basic.string/string.modifiers/string_append/string_size_size.pass.cpp b/libcxx/test/std/strings/basic.string/string.modifiers/string_append/string_size_size.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.modifiers/string_append/string_size_size.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.modifiers/string_append/string_size_size.pass.cpp
@@ -20,7 +20,7 @@
 #include "min_allocator.h"
 
 template <class S>
-void
+TEST_CONSTEXPR_CXX20 void
 test(S s, S str, typename S::size_type pos, typename S::size_type n, S expected)
 {
     if (pos <= str.size())
@@ -30,7 +30,7 @@
         assert(s == expected);
     }
 #ifndef TEST_HAS_NO_EXCEPTIONS
-    else
+    else if (!TEST_IS_CONSTANT_EVALUATED)
     {
         try
         {
@@ -46,7 +46,7 @@
 }
 
 template <class S>
-void
+TEST_CONSTEXPR_CXX20 void
 test_npos(S s, S str, typename S::size_type pos, S expected)
 {
     if (pos <= str.size())
@@ -56,7 +56,7 @@
         assert(s == expected);
     }
 #ifndef TEST_HAS_NO_EXCEPTIONS
-    else
+    else if (!TEST_IS_CONSTANT_EVALUATED)
     {
         try
         {
@@ -71,7 +71,8 @@
 #endif
 }
 
-int main(int, char**)
+TEST_CONSTEXPR_CXX20
+bool test()
 {
     {
     typedef std::string S;
@@ -134,5 +135,14 @@
     test_npos(S(), S("12345"), 6, S("not happening"));
     }
 
+    return true;
+}
+
+int main(int, char**) {
+  test();
+#if TEST_STD_VER > 17
+  static_assert(test());
+#endif
+
   return 0;
 }
diff --git a/libcxx/test/std/strings/basic.string/string.modifiers/string_append/string_view.pass.cpp b/libcxx/test/std/strings/basic.string/string.modifiers/string_append/string_view.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.modifiers/string_append/string_view.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.modifiers/string_append/string_view.pass.cpp
@@ -19,7 +19,7 @@
 #include "min_allocator.h"
 
 template <class S, class SV>
-void
+TEST_CONSTEXPR_CXX20 void
 test(S s, SV sv, S expected)
 {
     s.append(sv);
@@ -27,7 +27,8 @@
     assert(s == expected);
 }
 
-int main(int, char**)
+TEST_CONSTEXPR_CXX20
+bool test()
 {
     {
     typedef std::string S;
@@ -80,5 +81,14 @@
     }
 #endif
 
+    return true;
+}
+
+int main(int, char**) {
+  test();
+#if TEST_STD_VER > 17
+  static_assert(test());
+#endif
+
   return 0;
 }
diff --git a/libcxx/test/std/strings/basic.string/string.modifiers/string_assign/T_size_size.pass.cpp b/libcxx/test/std/strings/basic.string/string.modifiers/string_assign/T_size_size.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.modifiers/string_assign/T_size_size.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.modifiers/string_assign/T_size_size.pass.cpp
@@ -19,7 +19,7 @@
 #include "min_allocator.h"
 
 template <class S, class SV>
-void
+TEST_CONSTEXPR_CXX20 void
 test(S s, SV sv, typename S::size_type pos, typename S::size_type n, S expected)
 {
     if (pos <= sv.size())
@@ -29,7 +29,7 @@
         assert(s == expected);
     }
 #ifndef TEST_HAS_NO_EXCEPTIONS
-    else
+    else if (!TEST_IS_CONSTANT_EVALUATED)
     {
         try
         {
@@ -45,7 +45,7 @@
 }
 
 template <class S, class SV>
-void
+TEST_CONSTEXPR_CXX20 void
 test_npos(S s, SV sv, typename S::size_type pos, S expected)
 {
     if (pos <= sv.size())
@@ -55,7 +55,7 @@
         assert(s == expected);
     }
 #ifndef TEST_HAS_NO_EXCEPTIONS
-    else
+    else if (!TEST_IS_CONSTANT_EVALUATED)
     {
         try
         {
@@ -70,8 +70,7 @@
 #endif
 }
 
-int main(int, char**)
-{
+TEST_CONSTEXPR_CXX20 bool test() {
     {
     typedef std::string S;
     typedef std::string_view SV;
@@ -192,5 +191,14 @@
     assert(s == "ABCDEFGHIJKLMNOPQRSTUVWXYZ");
     }
 
+    return true;
+}
+
+int main(int, char**) {
+  test();
+#if TEST_STD_VER > 17
+  static_assert(test());
+#endif
+
   return 0;
 }
diff --git a/libcxx/test/std/strings/basic.string/string.modifiers/string_assign/initializer_list.pass.cpp b/libcxx/test/std/strings/basic.string/string.modifiers/string_assign/initializer_list.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.modifiers/string_assign/initializer_list.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.modifiers/string_assign/initializer_list.pass.cpp
@@ -18,7 +18,8 @@
 #include "test_macros.h"
 #include "min_allocator.h"
 
-int main(int, char**)
+TEST_CONSTEXPR_CXX20
+bool test()
 {
     {
         std::string s("123");
@@ -31,6 +32,14 @@
         s.assign({'a', 'b', 'c'});
         assert(s == "abc");
     }
+    return true;
+}
+
+int main(int, char**) {
+  test();
+#if TEST_STD_VER > 17
+  static_assert(test());
+#endif
 
   return 0;
 }
diff --git a/libcxx/test/std/strings/basic.string/string.modifiers/string_assign/iterator.pass.cpp b/libcxx/test/std/strings/basic.string/string.modifiers/string_assign/iterator.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.modifiers/string_assign/iterator.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.modifiers/string_assign/iterator.pass.cpp
@@ -19,7 +19,7 @@
 #include "min_allocator.h"
 
 template <class S, class It>
-void
+TEST_CONSTEXPR_CXX20 void
 test(S s, It first, It last, S expected)
 {
     s.assign(first, last);
@@ -52,9 +52,10 @@
 }
 #endif
 
-int main(int, char**)
+TEST_CONSTEXPR_CXX20
+bool test()
 {
-    {
+     {
     typedef std::string S;
     const char* s = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
     test(S(), s, s, S());
@@ -173,7 +174,7 @@
     }
 #endif
 #ifndef TEST_HAS_NO_EXCEPTIONS
-    { // test iterator operations that throw
+    if (!TEST_IS_CONSTANT_EVALUATED) { // test iterator operations that throw
     typedef std::string S;
     typedef ThrowingIterator<char> TIter;
     typedef cpp17_input_iterator<TIter> IIter;
@@ -224,5 +225,14 @@
     test(sneaky, sneaky.data(), sneaky.data() + sneaky.size() + 1, expected);
     }
 
-    return 0;
+    return true;
+}
+
+int main(int, char**) {
+  test();
+#if TEST_STD_VER > 17
+  static_assert(test());
+#endif
+
+  return 0;
 }
diff --git a/libcxx/test/std/strings/basic.string/string.modifiers/string_assign/pointer.pass.cpp b/libcxx/test/std/strings/basic.string/string.modifiers/string_assign/pointer.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.modifiers/string_assign/pointer.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.modifiers/string_assign/pointer.pass.cpp
@@ -18,7 +18,7 @@
 #include "min_allocator.h"
 
 template <class S>
-void
+TEST_CONSTEXPR_CXX20 void
 test(S s, const typename S::value_type* str, S expected)
 {
     s.assign(str);
@@ -26,8 +26,7 @@
     assert(s == expected);
 }
 
-int main(int, char**)
-{
+TEST_CONSTEXPR_CXX20 bool test() {
     {
     typedef std::string S;
     test(S(), "", S());
@@ -75,5 +74,14 @@
     assert(s_long == "nsectetur/");
     }
 
+    return true;
+}
+
+int main(int, char**) {
+  test();
+#if TEST_STD_VER > 17
+  static_assert(test());
+#endif
+
   return 0;
 }
diff --git a/libcxx/test/std/strings/basic.string/string.modifiers/string_assign/pointer_size.pass.cpp b/libcxx/test/std/strings/basic.string/string.modifiers/string_assign/pointer_size.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.modifiers/string_assign/pointer_size.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.modifiers/string_assign/pointer_size.pass.cpp
@@ -19,7 +19,7 @@
 #include "min_allocator.h"
 
 template <class S>
-void
+TEST_CONSTEXPR_CXX20 void
 test(S s, const typename S::value_type* str, typename S::size_type n, S expected)
 {
     s.assign(str, n);
@@ -27,8 +27,7 @@
     assert(s == expected);
 }
 
-int main(int, char**)
-{
+TEST_CONSTEXPR_CXX20 bool test() {
     {
     typedef std::string S;
     test(S(), "", 0, S());
@@ -86,5 +85,14 @@
     assert(s_long == "rem ipsu");
     }
 
+    return true;
+}
+
+int main(int, char**) {
+  test();
+#if TEST_STD_VER > 17
+  static_assert(test());
+#endif
+
   return 0;
 }
diff --git a/libcxx/test/std/strings/basic.string/string.modifiers/string_assign/rv_string.pass.cpp b/libcxx/test/std/strings/basic.string/string.modifiers/string_assign/rv_string.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.modifiers/string_assign/rv_string.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.modifiers/string_assign/rv_string.pass.cpp
@@ -19,7 +19,7 @@
 #include "min_allocator.h"
 
 template <class S>
-void
+TEST_CONSTEXPR_CXX20 void
 test(S s, S str, S expected)
 {
     s.assign(std::move(str));
@@ -27,8 +27,7 @@
     assert(s == expected);
 }
 
-int main(int, char**)
-{
+TEST_CONSTEXPR_CXX20 bool test() {
     {
     typedef std::string S;
     test(S(), S(), S());
@@ -78,5 +77,14 @@
     }
 #endif
 
+    return true;
+}
+
+int main(int, char**) {
+  test();
+#if TEST_STD_VER > 17
+  static_assert(test());
+#endif
+
   return 0;
 }
diff --git a/libcxx/test/std/strings/basic.string/string.modifiers/string_assign/size_char.pass.cpp b/libcxx/test/std/strings/basic.string/string.modifiers/string_assign/size_char.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.modifiers/string_assign/size_char.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.modifiers/string_assign/size_char.pass.cpp
@@ -18,7 +18,7 @@
 #include "min_allocator.h"
 
 template <class S>
-void
+TEST_CONSTEXPR_CXX20 void
 test(S s, typename S::size_type n, typename S::value_type c, S expected)
 {
     s.assign(n, c);
@@ -26,8 +26,7 @@
     assert(s == expected);
 }
 
-int main(int, char**)
-{
+TEST_CONSTEXPR_CXX20 bool test() {
     {
     typedef std::string S;
     test(S(), 0, 'a', S());
@@ -61,5 +60,14 @@
     }
 #endif
 
+    return true;
+}
+
+int main(int, char**) {
+  test();
+#if TEST_STD_VER > 17
+  static_assert(test());
+#endif
+
   return 0;
 }
diff --git a/libcxx/test/std/strings/basic.string/string.modifiers/string_assign/string.pass.cpp b/libcxx/test/std/strings/basic.string/string.modifiers/string_assign/string.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.modifiers/string_assign/string.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.modifiers/string_assign/string.pass.cpp
@@ -19,7 +19,7 @@
 #include "test_allocator.h"
 
 template <class S>
-void
+TEST_CONSTEXPR_CXX20 void
 test(S s, S str, S expected)
 {
     s.assign(str);
@@ -28,7 +28,7 @@
 }
 
 template <class S>
-void
+TEST_CONSTEXPR_CXX20 void
 testAlloc(S s, S str, const typename S::allocator_type& a)
 {
     s.assign(str);
@@ -37,8 +37,7 @@
     assert(s.get_allocator() == a);
 }
 
-int main(int, char**)
-{
+TEST_CONSTEXPR_CXX20 bool test() {
     {
     typedef std::string S;
     test(S(), S(), S());
@@ -114,5 +113,14 @@
     }
 #endif
 
+    return true;
+}
+
+int main(int, char**) {
+  test();
+#if TEST_STD_VER > 17
+  static_assert(test());
+#endif
+
   return 0;
 }
diff --git a/libcxx/test/std/strings/basic.string/string.modifiers/string_assign/string_size_size.pass.cpp b/libcxx/test/std/strings/basic.string/string.modifiers/string_assign/string_size_size.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.modifiers/string_assign/string_size_size.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.modifiers/string_assign/string_size_size.pass.cpp
@@ -20,7 +20,7 @@
 #include "min_allocator.h"
 
 template <class S>
-void
+TEST_CONSTEXPR_CXX20 void
 test(S s, S str, typename S::size_type pos, typename S::size_type n, S expected)
 {
     if (pos <= str.size())
@@ -30,7 +30,7 @@
         assert(s == expected);
     }
 #ifndef TEST_HAS_NO_EXCEPTIONS
-    else
+    else if (!TEST_IS_CONSTANT_EVALUATED)
     {
         try
         {
@@ -46,7 +46,7 @@
 }
 
 template <class S>
-void
+TEST_CONSTEXPR_CXX20 void
 test_npos(S s, S str, typename S::size_type pos, S expected)
 {
     if (pos <= str.size())
@@ -56,7 +56,7 @@
         assert(s == expected);
     }
 #ifndef TEST_HAS_NO_EXCEPTIONS
-    else
+    else if (!TEST_IS_CONSTANT_EVALUATED)
     {
         try
         {
@@ -71,8 +71,7 @@
 #endif
 }
 
-int main(int, char**)
-{
+TEST_CONSTEXPR_CXX20 bool test() {
     {
     typedef std::string S;
     test(S(), S(), 0, 0, S());
@@ -134,5 +133,14 @@
     test_npos(S(), S("12345"), 6, S("not happening"));
     }
 
+    return true;
+}
+
+int main(int, char**) {
+  test();
+#if TEST_STD_VER > 17
+  static_assert(test());
+#endif
+
   return 0;
 }
diff --git a/libcxx/test/std/strings/basic.string/string.modifiers/string_assign/string_view.pass.cpp b/libcxx/test/std/strings/basic.string/string.modifiers/string_assign/string_view.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.modifiers/string_assign/string_view.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.modifiers/string_assign/string_view.pass.cpp
@@ -20,7 +20,7 @@
 #include "test_allocator.h"
 
 template <class S, class SV>
-void
+TEST_CONSTEXPR_CXX20 void
 test(S s, SV sv, S expected)
 {
     s.assign(sv);
@@ -29,7 +29,7 @@
 }
 
 template <class S, class SV>
-void
+TEST_CONSTEXPR_CXX20 void
 testAlloc(S s, SV sv, const typename S::allocator_type& a)
 {
     s.assign(sv);
@@ -38,8 +38,7 @@
     assert(s.get_allocator() == a);
 }
 
-int main(int, char**)
-{
+TEST_CONSTEXPR_CXX20 bool test() {
     {
     typedef std::string S;
     typedef std::string_view SV;
@@ -102,5 +101,14 @@
     }
 #endif
 
+    return true;
+}
+
+int main(int, char**) {
+  test();
+#if TEST_STD_VER > 17
+  static_assert(test());
+#endif
+
   return 0;
 }
diff --git a/libcxx/test/std/strings/basic.string/string.modifiers/string_copy/copy.pass.cpp b/libcxx/test/std/strings/basic.string/string.modifiers/string_copy/copy.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.modifiers/string_copy/copy.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.modifiers/string_copy/copy.pass.cpp
@@ -19,7 +19,7 @@
 #include "min_allocator.h"
 
 template <class S>
-void
+TEST_CONSTEXPR_CXX20 void
 test(S str, typename S::value_type* s, typename S::size_type n,
      typename S::size_type pos)
 {
@@ -33,7 +33,7 @@
             assert(S::traits_type::eq(cs[pos+r], s[r]));
     }
 #ifndef TEST_HAS_NO_EXCEPTIONS
-    else
+    else if (!TEST_IS_CONSTANT_EVALUATED)
     {
         try
         {
@@ -49,8 +49,7 @@
 #endif
 }
 
-int main(int, char**)
-{
+TEST_CONSTEXPR_CXX20 bool test() {
     {
     typedef std::string S;
     char s[50];
@@ -178,5 +177,14 @@
     }
 #endif
 
+    return true;
+}
+
+int main(int, char**) {
+  test();
+#if TEST_STD_VER > 17
+  static_assert(test());
+#endif
+
   return 0;
 }
diff --git a/libcxx/test/std/strings/basic.string/string.modifiers/string_erase/iter.pass.cpp b/libcxx/test/std/strings/basic.string/string.modifiers/string_erase/iter.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.modifiers/string_erase/iter.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.modifiers/string_erase/iter.pass.cpp
@@ -17,7 +17,7 @@
 #include "min_allocator.h"
 
 template <class S>
-void
+TEST_CONSTEXPR_CXX20 void
 test(S s, typename S::difference_type pos, S expected)
 {
     typename S::const_iterator p = s.begin() + pos;
@@ -28,8 +28,7 @@
     assert(i - s.begin() == pos);
 }
 
-int main(int, char**)
-{
+TEST_CONSTEXPR_CXX20 bool test() {
     {
     typedef std::string S;
     test(S("abcde"), 0, S("bcde"));
@@ -63,5 +62,14 @@
     }
 #endif
 
+    return true;
+}
+
+int main(int, char**) {
+  test();
+#if TEST_STD_VER > 17
+  static_assert(test());
+#endif
+
   return 0;
 }
diff --git a/libcxx/test/std/strings/basic.string/string.modifiers/string_erase/iter_iter.pass.cpp b/libcxx/test/std/strings/basic.string/string.modifiers/string_erase/iter_iter.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.modifiers/string_erase/iter_iter.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.modifiers/string_erase/iter_iter.pass.cpp
@@ -17,7 +17,7 @@
 #include "min_allocator.h"
 
 template <class S>
-void
+TEST_CONSTEXPR_CXX20 void
 test(S s, typename S::difference_type pos, typename S::difference_type n, S expected)
 {
     typename S::const_iterator first = s.cbegin() + pos;
@@ -29,8 +29,7 @@
     assert(i - s.begin() == pos);
 }
 
-int main(int, char**)
-{
+TEST_CONSTEXPR_CXX20 bool test() {
     {
     typedef std::string S;
     test(S(""), 0, 0, S(""));
@@ -148,5 +147,14 @@
     }
 #endif
 
+    return true;
+}
+
+int main(int, char**) {
+  test();
+#if TEST_STD_VER > 17
+  static_assert(test());
+#endif
+
   return 0;
 }
diff --git a/libcxx/test/std/strings/basic.string/string.modifiers/string_erase/pop_back.pass.cpp b/libcxx/test/std/strings/basic.string/string.modifiers/string_erase/pop_back.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.modifiers/string_erase/pop_back.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.modifiers/string_erase/pop_back.pass.cpp
@@ -17,7 +17,7 @@
 #include "min_allocator.h"
 
 template <class S>
-void
+TEST_CONSTEXPR_CXX20 void
 test(S s, S expected)
 {
     s.pop_back();
@@ -26,8 +26,7 @@
     assert(s == expected);
 }
 
-int main(int, char**)
-{
+TEST_CONSTEXPR_CXX20 bool test() {
     {
     typedef std::string S;
     test(S("abcde"), S("abcd"));
@@ -43,5 +42,14 @@
     }
 #endif
 
+    return true;
+}
+
+int main(int, char**) {
+  test();
+#if TEST_STD_VER > 17
+  static_assert(test());
+#endif
+
   return 0;
 }
diff --git a/libcxx/test/std/strings/basic.string/string.modifiers/string_erase/size_size.pass.cpp b/libcxx/test/std/strings/basic.string/string.modifiers/string_erase/size_size.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.modifiers/string_erase/size_size.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.modifiers/string_erase/size_size.pass.cpp
@@ -19,7 +19,7 @@
 #include "min_allocator.h"
 
 template <class S>
-void
+TEST_CONSTEXPR_CXX20 void
 test(S s, typename S::size_type pos, typename S::size_type n, S expected)
 {
     const typename S::size_type old_size = s.size();
@@ -32,7 +32,7 @@
         assert(s == expected);
     }
 #ifndef TEST_HAS_NO_EXCEPTIONS
-    else
+    else if (!TEST_IS_CONSTANT_EVALUATED)
     {
         try
         {
@@ -49,7 +49,7 @@
 }
 
 template <class S>
-void
+TEST_CONSTEXPR_CXX20 void
 test(S s, typename S::size_type pos, S expected)
 {
     const typename S::size_type old_size = s.size();
@@ -62,7 +62,7 @@
         assert(s == expected);
     }
 #ifndef TEST_HAS_NO_EXCEPTIONS
-    else
+    else if (!TEST_IS_CONSTANT_EVALUATED)
     {
         try
         {
@@ -79,7 +79,7 @@
 }
 
 template <class S>
-void
+TEST_CONSTEXPR_CXX20 void
 test(S s, S expected)
 {
     s.erase();
@@ -88,8 +88,7 @@
     assert(s == expected);
 }
 
-int main(int, char**)
-{
+TEST_CONSTEXPR_CXX20 bool test() {
     {
     typedef std::string S;
     test(S(""), 0, 0, S(""));
@@ -299,5 +298,14 @@
     }
 #endif
 
+    return true;
+}
+
+int main(int, char**) {
+  test();
+#if TEST_STD_VER > 17
+  static_assert(test());
+#endif
+
   return 0;
 }
diff --git a/libcxx/test/std/strings/basic.string/string.modifiers/string_insert/iter_char.pass.cpp b/libcxx/test/std/strings/basic.string/string.modifiers/string_insert/iter_char.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.modifiers/string_insert/iter_char.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.modifiers/string_insert/iter_char.pass.cpp
@@ -18,7 +18,7 @@
 #include "min_allocator.h"
 
 template <class S>
-void
+TEST_CONSTEXPR_CXX20 void
 test(S& s, typename S::const_iterator p, typename S::value_type c, S expected)
 {
     bool sufficient_cap = s.size() < s.capacity();
@@ -32,8 +32,7 @@
         assert(i == p);
 }
 
-int main(int, char**)
-{
+TEST_CONSTEXPR_CXX20 bool test() {
     {
     typedef std::string S;
     S s;
@@ -73,5 +72,14 @@
     }
 #endif
 
+    return true;
+}
+
+int main(int, char**) {
+  test();
+#if TEST_STD_VER > 17
+  static_assert(test());
+#endif
+
   return 0;
 }
diff --git a/libcxx/test/std/strings/basic.string/string.modifiers/string_insert/iter_initializer_list.pass.cpp b/libcxx/test/std/strings/basic.string/string.modifiers/string_insert/iter_initializer_list.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.modifiers/string_insert/iter_initializer_list.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.modifiers/string_insert/iter_initializer_list.pass.cpp
@@ -19,8 +19,7 @@
 #include "test_macros.h"
 #include "min_allocator.h"
 
-int main(int, char**)
-{
+TEST_CONSTEXPR_CXX20 bool test() {
     {
         std::string s("123456");
         std::string::iterator i = s.insert(s.begin() + 3, {'a', 'b', 'c'});
@@ -35,5 +34,14 @@
         assert(s == "123abc456");
     }
 
+    return true;
+}
+
+int main(int, char**) {
+  test();
+#if TEST_STD_VER > 17
+  static_assert(test());
+#endif
+
   return 0;
 }
diff --git a/libcxx/test/std/strings/basic.string/string.modifiers/string_insert/iter_iter_iter.pass.cpp b/libcxx/test/std/strings/basic.string/string.modifiers/string_insert/iter_iter_iter.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.modifiers/string_insert/iter_iter_iter.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.modifiers/string_insert/iter_iter_iter.pass.cpp
@@ -19,7 +19,7 @@
 #include "min_allocator.h"
 
 template <class S, class It>
-void
+TEST_CONSTEXPR_CXX20 void
 test(S s, typename S::difference_type pos, It first, It last, S expected)
 {
     typename S::const_iterator p = s.cbegin() + pos;
@@ -33,7 +33,7 @@
 struct Widget { operator char() const { throw 42; } };
 
 template <class S, class It>
-void
+TEST_CONSTEXPR_CXX20 void
 test_exceptions(S s, typename S::difference_type pos, It first, It last)
 {
     typename S::const_iterator p = s.cbegin() + pos;
@@ -56,9 +56,8 @@
 }
 #endif
 
-int main(int, char**)
-{
-    {
+TEST_CONSTEXPR_CXX20 bool test() {
+  {
     typedef std::string S;
     const char* s = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
     test(S(), 0, s, s, S());
@@ -151,7 +150,7 @@
     }
 #endif
 #ifndef TEST_HAS_NO_EXCEPTIONS
-    { // test iterator operations that throw
+    if (!TEST_IS_CONSTANT_EVALUATED) { // test iterator operations that throw
     typedef std::string S;
     typedef ThrowingIterator<char> TIter;
     typedef cpp17_input_iterator<TIter> IIter;
@@ -194,7 +193,7 @@
     assert(s == "ABCD");
     }
 
-    { // regression-test inserting into self in sneaky ways
+    if (!TEST_IS_CONSTANT_EVALUATED) { // regression-test inserting into self in sneaky ways
     std::string s_short = "hello";
     std::string s_long = "Lorem ipsum dolor sit amet, consectetur/";
     std::string s_othertype = "hello";
@@ -232,5 +231,14 @@
     assert(s == "ABCD");
   }
 
+  return true;
+}
+
+int main(int, char**) {
+  test();
+#if TEST_STD_VER > 17
+  static_assert(test());
+#endif
+
   return 0;
 }
diff --git a/libcxx/test/std/strings/basic.string/string.modifiers/string_insert/iter_size_char.pass.cpp b/libcxx/test/std/strings/basic.string/string.modifiers/string_insert/iter_size_char.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.modifiers/string_insert/iter_size_char.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.modifiers/string_insert/iter_size_char.pass.cpp
@@ -17,7 +17,7 @@
 #include "min_allocator.h"
 
 template <class S>
-void
+TEST_CONSTEXPR_CXX20 void
 test(S s, typename S::difference_type pos, typename S::size_type n,
      typename S::value_type c, S expected)
 {
@@ -28,8 +28,7 @@
     assert(s == expected);
 }
 
-int main(int, char**)
-{
+TEST_CONSTEXPR_CXX20 bool test() {
     {
     typedef std::string S;
     test(S(""), 0, 0, '1', S(""));
@@ -167,5 +166,14 @@
     }
 #endif
 
+    return true;
+}
+
+int main(int, char**) {
+  test();
+#if TEST_STD_VER > 17
+  static_assert(test());
+#endif
+
   return 0;
 }
diff --git a/libcxx/test/std/strings/basic.string/string.modifiers/string_insert/size_pointer.pass.cpp b/libcxx/test/std/strings/basic.string/string.modifiers/string_insert/size_pointer.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.modifiers/string_insert/size_pointer.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.modifiers/string_insert/size_pointer.pass.cpp
@@ -19,7 +19,7 @@
 #include "min_allocator.h"
 
 template <class S>
-void
+TEST_CONSTEXPR_CXX20 void
 test(S s, typename S::size_type pos, const typename S::value_type* str, S expected)
 {
     const typename S::size_type old_size = s.size();
@@ -31,7 +31,7 @@
         assert(s == expected);
     }
 #ifndef TEST_HAS_NO_EXCEPTIONS
-    else
+    else if (!TEST_IS_CONSTANT_EVALUATED)
     {
         try
         {
@@ -47,8 +47,7 @@
 #endif
 }
 
-int main(int, char**)
-{
+TEST_CONSTEXPR_CXX20 bool test() {
     {
     typedef std::string S;
     test(S(""), 0, "", S(""));
@@ -234,5 +233,14 @@
     assert(s_long == "Lorem ipsum dolor sit amet, consectetur/Lorem ipsum dolor sit amet, consectetur/");
     }
 
+    return true;
+}
+
+int main(int, char**) {
+  test();
+#if TEST_STD_VER > 17
+  static_assert(test());
+#endif
+
   return 0;
 }
diff --git a/libcxx/test/std/strings/basic.string/string.modifiers/string_insert/size_pointer_size.pass.cpp b/libcxx/test/std/strings/basic.string/string.modifiers/string_insert/size_pointer_size.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.modifiers/string_insert/size_pointer_size.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.modifiers/string_insert/size_pointer_size.pass.cpp
@@ -19,7 +19,7 @@
 #include "min_allocator.h"
 
 template <class S>
-void
+TEST_CONSTEXPR_CXX20 void
 test(S s, typename S::size_type pos, const typename S::value_type* str,
      typename S::size_type n, S expected)
 {
@@ -32,7 +32,7 @@
         assert(s == expected);
     }
 #ifndef TEST_HAS_NO_EXCEPTIONS
-    else
+    else if (!TEST_IS_CONSTANT_EVALUATED)
     {
         try
         {
@@ -48,8 +48,7 @@
 #endif
 }
 
-int main(int, char**)
-{
+TEST_CONSTEXPR_CXX20 bool test() {
     {
     typedef std::string S;
     test(S(""), 0, "", 0, S(""));
@@ -715,5 +714,14 @@
     assert(s_long == "Lorem ipsum dolor sit amet, consectetur/Lorem ipsum dolor sit amet, consectetur/");
     }
 
+    return true;
+}
+
+int main(int, char**) {
+  test();
+#if TEST_STD_VER > 17
+  static_assert(test());
+#endif
+
   return 0;
 }
diff --git a/libcxx/test/std/strings/basic.string/string.modifiers/string_insert/size_size_char.pass.cpp b/libcxx/test/std/strings/basic.string/string.modifiers/string_insert/size_size_char.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.modifiers/string_insert/size_size_char.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.modifiers/string_insert/size_size_char.pass.cpp
@@ -19,7 +19,7 @@
 #include "min_allocator.h"
 
 template <class S>
-void
+TEST_CONSTEXPR_CXX20 void
 test(S s, typename S::size_type pos, typename S::size_type n,
      typename S::value_type str, S expected)
 {
@@ -32,7 +32,7 @@
         assert(s == expected);
     }
 #ifndef TEST_HAS_NO_EXCEPTIONS
-    else
+    else if (!TEST_IS_CONSTANT_EVALUATED)
     {
         try
         {
@@ -48,8 +48,7 @@
 #endif
 }
 
-int main(int, char**)
-{
+TEST_CONSTEXPR_CXX20 bool test() {
     {
     typedef std::string S;
     test(S(""), 0, 0, '1', S(""));
@@ -219,5 +218,14 @@
     }
 #endif
 
+    return true;
+}
+
+int main(int, char**) {
+  test();
+#if TEST_STD_VER > 17
+  static_assert(test());
+#endif
+
   return 0;
 }
diff --git a/libcxx/test/std/strings/basic.string/string.modifiers/string_insert/size_string.pass.cpp b/libcxx/test/std/strings/basic.string/string.modifiers/string_insert/size_string.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.modifiers/string_insert/size_string.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.modifiers/string_insert/size_string.pass.cpp
@@ -19,7 +19,8 @@
 #include "min_allocator.h"
 
 template <class S>
-void
+
+TEST_CONSTEXPR_CXX20 void
 test(S s, typename S::size_type pos, S str, S expected)
 {
     const typename S::size_type old_size = s.size();
@@ -31,7 +32,7 @@
         assert(s == expected);
     }
 #ifndef TEST_HAS_NO_EXCEPTIONS
-    else
+    else if (!TEST_IS_CONSTANT_EVALUATED)
     {
         try
         {
@@ -47,8 +48,7 @@
 #endif
 }
 
-int main(int, char**)
-{
+TEST_CONSTEXPR_CXX20 bool test() {
     {
     typedef std::string S;
     test(S(""), 0, S(""), S(""));
@@ -227,5 +227,14 @@
     }
 #endif
 
+    return true;
+}
+
+int main(int, char**) {
+  test();
+#if TEST_STD_VER > 17
+  static_assert(test());
+#endif
+
   return 0;
 }
diff --git a/libcxx/test/std/strings/basic.string/string.modifiers/string_insert/size_string_size_size.pass.cpp b/libcxx/test/std/strings/basic.string/string.modifiers/string_insert/size_string_size_size.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.modifiers/string_insert/size_string_size_size.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.modifiers/string_insert/size_string_size_size.pass.cpp
@@ -21,7 +21,7 @@
 #include "min_allocator.h"
 
 template <class S>
-void
+TEST_CONSTEXPR_CXX20 void
 test(S s, typename S::size_type pos1, S str, typename S::size_type pos2,
      typename S::size_type n, S expected)
 {
@@ -34,7 +34,7 @@
         assert(s == expected);
     }
 #ifndef TEST_HAS_NO_EXCEPTIONS
-    else
+    else if (!TEST_IS_CONSTANT_EVALUATED)
     {
         try
         {
@@ -51,7 +51,7 @@
 }
 
 template <class S>
-void
+TEST_CONSTEXPR_CXX20 void
 test_npos(S s, typename S::size_type pos1, S str, typename S::size_type pos2, S expected)
 {
     const typename S::size_type old_size = s.size();
@@ -63,7 +63,7 @@
         assert(s == expected);
     }
 #ifndef TEST_HAS_NO_EXCEPTIONS
-    else
+    else if (!TEST_IS_CONSTANT_EVALUATED)
     {
         try
         {
@@ -81,7 +81,7 @@
 
 
 template <class S>
-void test0()
+TEST_CONSTEXPR_CXX20 void test0()
 {
     test(S(""), 0, S(""), 0, 0, S(""));
     test(S(""), 0, S(""), 0, 1, S(""));
@@ -136,7 +136,7 @@
 }
 
 template <class S>
-void test1()
+TEST_CONSTEXPR_CXX20 void test1()
 {
     test(S(""), 0, S("12345678901234567890"), 0, 0, S(""));
     test(S(""), 0, S("12345678901234567890"), 0, 1, S("1"));
@@ -191,7 +191,7 @@
 }
 
 template <class S>
-void test2()
+TEST_CONSTEXPR_CXX20 void test2()
 {
     test(S(""), 1, S("1234567890"), 0, 0, S("can't happen"));
     test(S(""), 1, S("1234567890"), 0, 1, S("can't happen"));
@@ -246,7 +246,7 @@
 }
 
 template <class S>
-void test3()
+TEST_CONSTEXPR_CXX20 void test3()
 {
     test(S("abcde"), 0, S(""), 1, 0, S("can't happen"));
     test(S("abcde"), 0, S("12345"), 0, 0, S("abcde"));
@@ -301,7 +301,7 @@
 }
 
 template <class S>
-void test4()
+TEST_CONSTEXPR_CXX20 void test4()
 {
     test(S("abcde"), 0, S("12345678901234567890"), 0, 10, S("1234567890abcde"));
     test(S("abcde"), 0, S("12345678901234567890"), 0, 19, S("1234567890123456789abcde"));
@@ -356,7 +356,7 @@
 }
 
 template <class S>
-void test5()
+TEST_CONSTEXPR_CXX20 void test5()
 {
     test(S("abcde"), 1, S("1234567890"), 0, 5, S("a12345bcde"));
     test(S("abcde"), 1, S("1234567890"), 0, 9, S("a123456789bcde"));
@@ -411,7 +411,7 @@
 }
 
 template <class S>
-void test6()
+TEST_CONSTEXPR_CXX20 void test6()
 {
     test(S("abcde"), 2, S("12345"), 0, 1, S("ab1cde"));
     test(S("abcde"), 2, S("12345"), 0, 2, S("ab12cde"));
@@ -466,7 +466,7 @@
 }
 
 template <class S>
-void test7()
+TEST_CONSTEXPR_CXX20 void test7()
 {
     test(S("abcde"), 2, S("12345678901234567890"), 0, 20, S("ab12345678901234567890cde"));
     test(S("abcde"), 2, S("12345678901234567890"), 0, 21, S("ab12345678901234567890cde"));
@@ -521,7 +521,7 @@
 }
 
 template <class S>
-void test8()
+TEST_CONSTEXPR_CXX20 void test8()
 {
     test(S("abcde"), 4, S("1234567890"), 0, 10, S("abcd1234567890e"));
     test(S("abcde"), 4, S("1234567890"), 0, 11, S("abcd1234567890e"));
@@ -576,7 +576,7 @@
 }
 
 template <class S>
-void test9()
+TEST_CONSTEXPR_CXX20 void test9()
 {
     test(S("abcde"), 5, S("12345"), 0, 4, S("abcde1234"));
     test(S("abcde"), 5, S("12345"), 0, 5, S("abcde12345"));
@@ -631,7 +631,7 @@
 }
 
 template <class S>
-void test10()
+TEST_CONSTEXPR_CXX20 void test10()
 {
     test(S("abcde"), 5, S("12345678901234567890"), 1, 0, S("abcde"));
     test(S("abcde"), 5, S("12345678901234567890"), 1, 1, S("abcde2"));
@@ -686,7 +686,7 @@
 }
 
 template <class S>
-void test11()
+TEST_CONSTEXPR_CXX20 void test11()
 {
     test(S("abcde"), 6, S("1234567890"), 1, 0, S("can't happen"));
     test(S("abcde"), 6, S("1234567890"), 1, 1, S("can't happen"));
@@ -741,7 +741,7 @@
 }
 
 template <class S>
-void test12()
+TEST_CONSTEXPR_CXX20 void test12()
 {
     test(S("abcdefghij"), 0, S("12345"), 0, 6, S("12345abcdefghij"));
     test(S("abcdefghij"), 0, S("12345"), 1, 0, S("abcdefghij"));
@@ -796,7 +796,7 @@
 }
 
 template <class S>
-void test13()
+TEST_CONSTEXPR_CXX20 void test13()
 {
     test(S("abcdefghij"), 0, S("12345678901234567890"), 1, 9, S("234567890abcdefghij"));
     test(S("abcdefghij"), 0, S("12345678901234567890"), 1, 18, S("234567890123456789abcdefghij"));
@@ -851,7 +851,7 @@
 }
 
 template <class S>
-void test14()
+TEST_CONSTEXPR_CXX20 void test14()
 {
     test(S("abcdefghij"), 1, S("1234567890"), 1, 4, S("a2345bcdefghij"));
     test(S("abcdefghij"), 1, S("1234567890"), 1, 8, S("a23456789bcdefghij"));
@@ -906,7 +906,7 @@
 }
 
 template <class S>
-void test15()
+TEST_CONSTEXPR_CXX20 void test15()
 {
     test(S("abcdefghij"), 5, S("12345"), 1, 1, S("abcde2fghij"));
     test(S("abcdefghij"), 5, S("12345"), 1, 2, S("abcde23fghij"));
@@ -961,7 +961,7 @@
 }
 
 template <class S>
-void test16()
+TEST_CONSTEXPR_CXX20 void test16()
 {
     test(S("abcdefghij"), 5, S("12345678901234567890"), 1, 19, S("abcde2345678901234567890fghij"));
     test(S("abcdefghij"), 5, S("12345678901234567890"), 1, 20, S("abcde2345678901234567890fghij"));
@@ -1016,7 +1016,7 @@
 }
 
 template <class S>
-void test17()
+TEST_CONSTEXPR_CXX20 void test17()
 {
     test(S("abcdefghij"), 9, S("1234567890"), 1, 9, S("abcdefghi234567890j"));
     test(S("abcdefghij"), 9, S("1234567890"), 1, 10, S("abcdefghi234567890j"));
@@ -1071,7 +1071,7 @@
 }
 
 template <class S>
-void test18()
+TEST_CONSTEXPR_CXX20 void test18()
 {
     test(S("abcdefghij"), 10, S("12345"), 1, 3, S("abcdefghij234"));
     test(S("abcdefghij"), 10, S("12345"), 1, 4, S("abcdefghij2345"));
@@ -1126,7 +1126,7 @@
 }
 
 template <class S>
-void test19()
+TEST_CONSTEXPR_CXX20 void test19()
 {
     test(S("abcdefghij"), 10, S("12345678901234567890"), 10, 0, S("abcdefghij"));
     test(S("abcdefghij"), 10, S("12345678901234567890"), 10, 1, S("abcdefghij1"));
@@ -1181,7 +1181,7 @@
 }
 
 template <class S>
-void test20()
+TEST_CONSTEXPR_CXX20 void test20()
 {
     test(S("abcdefghij"), 11, S("1234567890"), 5, 0, S("can't happen"));
     test(S("abcdefghij"), 11, S("1234567890"), 5, 1, S("can't happen"));
@@ -1236,7 +1236,7 @@
 }
 
 template <class S>
-void test21()
+TEST_CONSTEXPR_CXX20 void test21()
 {
     test(S("abcdefghijklmnopqrst"), 0, S("12345"), 1, 5, S("2345abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 0, S("12345"), 2, 0, S("abcdefghijklmnopqrst"));
@@ -1291,7 +1291,7 @@
 }
 
 template <class S>
-void test22()
+TEST_CONSTEXPR_CXX20 void test22()
 {
     test(S("abcdefghijklmnopqrst"), 0, S("12345678901234567890"), 10, 5, S("12345abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 0, S("12345678901234567890"), 10, 9, S("123456789abcdefghijklmnopqrst"));
@@ -1346,7 +1346,7 @@
 }
 
 template <class S>
-void test23()
+TEST_CONSTEXPR_CXX20 void test23()
 {
     test(S("abcdefghijklmnopqrst"), 1, S("1234567890"), 5, 2, S("a67bcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 1, S("1234567890"), 5, 4, S("a6789bcdefghijklmnopqrst"));
@@ -1401,7 +1401,7 @@
 }
 
 template <class S>
-void test24()
+TEST_CONSTEXPR_CXX20 void test24()
 {
     test(S("abcdefghijklmnopqrst"), 10, S("12345"), 2, 1, S("abcdefghij3klmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 10, S("12345"), 2, 2, S("abcdefghij34klmnopqrst"));
@@ -1456,7 +1456,7 @@
 }
 
 template <class S>
-void test25()
+TEST_CONSTEXPR_CXX20 void test25()
 {
     test(S("abcdefghijklmnopqrst"), 10, S("12345678901234567890"), 10, 10, S("abcdefghij1234567890klmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 10, S("12345678901234567890"), 10, 11, S("abcdefghij1234567890klmnopqrst"));
@@ -1511,7 +1511,7 @@
 }
 
 template <class S>
-void test26()
+TEST_CONSTEXPR_CXX20 void test26()
 {
     test(S("abcdefghijklmnopqrst"), 19, S("1234567890"), 5, 5, S("abcdefghijklmnopqrs67890t"));
     test(S("abcdefghijklmnopqrst"), 19, S("1234567890"), 5, 6, S("abcdefghijklmnopqrs67890t"));
@@ -1566,7 +1566,7 @@
 }
 
 template <class S>
-void test27()
+TEST_CONSTEXPR_CXX20 void test27()
 {
     test(S("abcdefghijklmnopqrst"), 20, S("12345"), 2, 3, S("abcdefghijklmnopqrst345"));
     test(S("abcdefghijklmnopqrst"), 20, S("12345"), 2, 4, S("abcdefghijklmnopqrst345"));
@@ -1621,7 +1621,7 @@
 }
 
 template <class S>
-void test28()
+TEST_CONSTEXPR_CXX20 void test28()
 {
     test(S("abcdefghijklmnopqrst"), 20, S("12345678901234567890"), 19, 0, S("abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 20, S("12345678901234567890"), 19, 1, S("abcdefghijklmnopqrst0"));
@@ -1676,7 +1676,7 @@
 }
 
 template <class S>
-void test29()
+TEST_CONSTEXPR_CXX20 void test29()
 {
     test(S("abcdefghijklmnopqrst"), 21, S("1234567890"), 9, 0, S("can't happen"));
     test(S("abcdefghijklmnopqrst"), 21, S("1234567890"), 9, 1, S("can't happen"));
@@ -1711,7 +1711,7 @@
 }
 
 template <class S>
-void test30()
+TEST_CONSTEXPR_CXX20 void test30()
 {
     test_npos(S(""), 0, S("12345678901234567890"),  0, S("12345678901234567890"));
     test_npos(S(""), 0, S("12345678901234567890"),  1, S( "2345678901234567890"));
@@ -1727,9 +1727,7 @@
     test_npos(S("abcdefghijklmnopqrst"), 10, S("12345"), 6, S("can't happen"));
 }
 
-int main(int, char**)
-{
-    {
+TEST_CONSTEXPR_CXX20 bool test_0() {
     typedef std::string S;
     test0<S>();
     test1<S>();
@@ -1741,6 +1739,12 @@
     test7<S>();
     test8<S>();
     test9<S>();
+    
+    return true;
+}
+
+TEST_CONSTEXPR_CXX20 bool test_1() {
+    typedef std::string S;
     test10<S>();
     test11<S>();
     test12<S>();
@@ -1751,6 +1755,12 @@
     test17<S>();
     test18<S>();
     test19<S>();
+
+    return true;
+}
+
+TEST_CONSTEXPR_CXX20 bool test_2() {
+    typedef std::string S;
     test20<S>();
     test21<S>();
     test22<S>();
@@ -1762,9 +1772,12 @@
     test28<S>();
     test29<S>();
     test30<S>();
-    }
+
+    return true;
+}
+
+TEST_CONSTEXPR_CXX20 bool test_3() {
 #if TEST_STD_VER >= 11
-    {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test0<S>();
     test1<S>();
@@ -1777,6 +1790,14 @@
     test8<S>();
     test9<S>();
     test10<S>();
+#endif
+    
+    return true;
+}
+
+TEST_CONSTEXPR_CXX20 bool test_4() {
+#if TEST_STD_VER >= 11
+    typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test11<S>();
     test12<S>();
     test13<S>();
@@ -1787,6 +1808,14 @@
     test18<S>();
     test19<S>();
     test20<S>();
+#endif
+
+    return true;
+}
+
+TEST_CONSTEXPR_CXX20 bool test_5() {
+#if TEST_STD_VER >= 11
+    typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test21<S>();
     test22<S>();
     test23<S>();
@@ -1797,7 +1826,25 @@
     test28<S>();
     test29<S>();
     test30<S>();
-    }
+#endif
+
+    return true;
+}
+
+int main(int, char**) {
+  test_0();
+  test_1();
+  test_2();
+  test_3();
+  test_4();
+  test_5();
+#if TEST_STD_VER > 17
+  static_assert(test_0());
+  static_assert(test_1());
+  static_assert(test_2());
+  static_assert(test_3());
+  static_assert(test_4());
+  static_assert(test_5());
 #endif
 
   return 0;
diff --git a/libcxx/test/std/strings/basic.string/string.modifiers/string_insert/string_view.pass.cpp b/libcxx/test/std/strings/basic.string/string.modifiers/string_insert/string_view.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.modifiers/string_insert/string_view.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.modifiers/string_insert/string_view.pass.cpp
@@ -19,7 +19,7 @@
 #include "min_allocator.h"
 
 template <class S, class SV>
-void
+TEST_CONSTEXPR_CXX20 void
 test(S s, typename S::size_type pos, SV sv, S expected)
 {
     const typename S::size_type old_size = s.size();
@@ -31,7 +31,7 @@
         assert(s == expected);
     }
 #ifndef TEST_HAS_NO_EXCEPTIONS
-    else
+    else if (!TEST_IS_CONSTANT_EVALUATED)
     {
         try
         {
@@ -47,8 +47,7 @@
 #endif
 }
 
-int main(int, char**)
-{
+TEST_CONSTEXPR_CXX20 bool test() {
     {
     typedef std::string S;
     typedef std::string_view SV;
@@ -236,5 +235,14 @@
     assert(s_long == "Lorem ipsum dolor sit amet, consectetur/Lorem ipsum dolor sit amet, consectetur/");
     }
 
+    return true;
+}
+
+int main(int, char**) {
+  test();
+#if TEST_STD_VER > 17
+  static_assert(test());
+#endif
+
   return 0;
 }
diff --git a/libcxx/test/std/strings/basic.string/string.modifiers/string_op_plus_equal/char.pass.cpp b/libcxx/test/std/strings/basic.string/string.modifiers/string_op_plus_equal/char.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.modifiers/string_op_plus_equal/char.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.modifiers/string_op_plus_equal/char.pass.cpp
@@ -17,7 +17,7 @@
 #include "min_allocator.h"
 
 template <class S>
-void
+TEST_CONSTEXPR_CXX20 void
 test(S s, typename S::value_type str, S expected)
 {
     s += str;
@@ -25,8 +25,7 @@
     assert(s == expected);
 }
 
-int main(int, char**)
-{
+TEST_CONSTEXPR_CXX20 bool test() {
     {
     typedef std::string S;
     test(S(), 'a', S("a"));
@@ -44,5 +43,14 @@
     }
 #endif
 
+    return true;
+}
+
+int main(int, char**) {
+  test();
+#if TEST_STD_VER > 17
+  static_assert(test());
+#endif
+
   return 0;
 }
diff --git a/libcxx/test/std/strings/basic.string/string.modifiers/string_op_plus_equal/initializer_list.pass.cpp b/libcxx/test/std/strings/basic.string/string.modifiers/string_op_plus_equal/initializer_list.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.modifiers/string_op_plus_equal/initializer_list.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.modifiers/string_op_plus_equal/initializer_list.pass.cpp
@@ -18,8 +18,7 @@
 #include "test_macros.h"
 #include "min_allocator.h"
 
-int main(int, char**)
-{
+TEST_CONSTEXPR_CXX20 bool test() {
     {
         std::string s("123");
         s += {'a', 'b', 'c'};
@@ -32,5 +31,14 @@
         assert(s == "123abc");
     }
 
+    return true;
+}
+
+int main(int, char**) {
+  test();
+#if TEST_STD_VER > 17
+  static_assert(test());
+#endif
+
   return 0;
 }
diff --git a/libcxx/test/std/strings/basic.string/string.modifiers/string_op_plus_equal/pointer.pass.cpp b/libcxx/test/std/strings/basic.string/string.modifiers/string_op_plus_equal/pointer.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.modifiers/string_op_plus_equal/pointer.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.modifiers/string_op_plus_equal/pointer.pass.cpp
@@ -17,7 +17,7 @@
 #include "min_allocator.h"
 
 template <class S>
-void
+TEST_CONSTEXPR_CXX20 void
 test(S s, const typename S::value_type* str, S expected)
 {
     s += str;
@@ -25,8 +25,7 @@
     assert(s == expected);
 }
 
-int main(int, char**)
-{
+TEST_CONSTEXPR_CXX20 bool test() {
     {
     typedef std::string S;
     test(S(), "", S());
@@ -76,5 +75,14 @@
     }
 #endif
 
+    return true;
+}
+
+int main(int, char**) {
+  test();
+#if TEST_STD_VER > 17
+  static_assert(test());
+#endif
+
   return 0;
 }
diff --git a/libcxx/test/std/strings/basic.string/string.modifiers/string_op_plus_equal/string.pass.cpp b/libcxx/test/std/strings/basic.string/string.modifiers/string_op_plus_equal/string.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.modifiers/string_op_plus_equal/string.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.modifiers/string_op_plus_equal/string.pass.cpp
@@ -18,7 +18,7 @@
 #include "min_allocator.h"
 
 template <class S>
-void
+TEST_CONSTEXPR_CXX20 void
 test(S s, S str, S expected)
 {
     s += str;
@@ -26,8 +26,7 @@
     assert(s == expected);
 }
 
-int main(int, char**)
-{
+TEST_CONSTEXPR_CXX20 bool test() {
     {
     typedef std::string S;
     test(S(), S(), S());
@@ -86,5 +85,14 @@
     }
 #endif
 
+    return true;
+}
+
+int main(int, char**) {
+  test();
+#if TEST_STD_VER > 17
+  static_assert(test());
+#endif
+
   return 0;
 }
diff --git a/libcxx/test/std/strings/basic.string/string.modifiers/string_replace/iter_iter_initializer_list.pass.cpp b/libcxx/test/std/strings/basic.string/string.modifiers/string_replace/iter_iter_initializer_list.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.modifiers/string_replace/iter_iter_initializer_list.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.modifiers/string_replace/iter_iter_initializer_list.pass.cpp
@@ -18,8 +18,7 @@
 #include "test_macros.h"
 #include "min_allocator.h"
 
-int main(int, char**)
-{
+TEST_CONSTEXPR_CXX20 bool test() {
     {
         std::string s("123def456");
         s.replace(s.cbegin() + 3, s.cbegin() + 6, {'a', 'b', 'c'});
@@ -32,5 +31,14 @@
         assert(s == "123abc456");
     }
 
+    return true;
+}
+
+int main(int, char**) {
+  test();
+#if TEST_STD_VER > 17
+  static_assert(test());
+#endif
+
   return 0;
 }
diff --git a/libcxx/test/std/strings/basic.string/string.modifiers/string_replace/iter_iter_iter_iter.pass.cpp b/libcxx/test/std/strings/basic.string/string.modifiers/string_replace/iter_iter_iter_iter.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.modifiers/string_replace/iter_iter_iter_iter.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.modifiers/string_replace/iter_iter_iter_iter.pass.cpp
@@ -21,7 +21,7 @@
 #include "test_iterators.h"
 
 template <class S, class It>
-void
+TEST_CONSTEXPR_CXX20 void
 test(S s, typename S::size_type pos1, typename S::size_type n1, It f, It l, S expected)
 {
     typename S::size_type old_size = s.size();
@@ -39,7 +39,7 @@
 struct Widget { operator char() const { throw 42; } };
 
 template <class S, class It>
-void
+TEST_CONSTEXPR_CXX20 void
 test_exceptions(S s, typename S::size_type pos1, typename S::size_type n1, It f, It l)
 {
     typename S::const_iterator first = s.begin() + pos1;
@@ -63,10 +63,10 @@
 }
 #endif
 
-const char* str = "12345678901234567890";
+TEST_CONSTEXPR const char* str = "12345678901234567890";
 
 template <class S>
-void test0()
+TEST_CONSTEXPR_CXX20 void test0()
 {
     test(S(""), 0, 0, str, str+0, S(""));
     test(S(""), 0, 0, str, str+0, S(""));
@@ -171,7 +171,7 @@
 }
 
 template <class S>
-void test1()
+TEST_CONSTEXPR_CXX20 void test1()
 {
     test(S("abcde"), 1, 0, str, str+4, S("a1234bcde"));
     test(S("abcde"), 1, 0, str, str+5, S("a12345bcde"));
@@ -276,7 +276,7 @@
 }
 
 template <class S>
-void test2()
+TEST_CONSTEXPR_CXX20 void test2()
 {
     test(S("abcde"), 2, 1, str, str+5, S("ab12345de"));
     test(S("abcde"), 2, 1, str, str+9, S("ab123456789de"));
@@ -381,7 +381,7 @@
 }
 
 template <class S>
-void test3()
+TEST_CONSTEXPR_CXX20 void test3()
 {
     test(S("abcdefghij"), 0, 0, str, str+1, S("1abcdefghij"));
     test(S("abcdefghij"), 0, 0, str, str+10, S("1234567890abcdefghij"));
@@ -486,7 +486,7 @@
 }
 
 template <class S>
-void test4()
+TEST_CONSTEXPR_CXX20 void test4()
 {
     test(S("abcdefghij"), 1, 4, str, str+0, S("afghij"));
     test(S("abcdefghij"), 1, 4, str, str+0, S("afghij"));
@@ -591,7 +591,7 @@
 }
 
 template <class S>
-void test5()
+TEST_CONSTEXPR_CXX20 void test5()
 {
     test(S("abcdefghij"), 5, 4, str, str+4, S("abcde1234j"));
     test(S("abcdefghij"), 5, 4, str, str+5, S("abcde12345j"));
@@ -696,7 +696,7 @@
 }
 
 template <class S>
-void test6()
+TEST_CONSTEXPR_CXX20 void test6()
 {
     test(S("abcdefghijklmnopqrst"), 0, 1, str, str+5, S("12345bcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 0, 1, str, str+9, S("123456789bcdefghijklmnopqrst"));
@@ -801,7 +801,7 @@
 }
 
 template <class S>
-void test7()
+TEST_CONSTEXPR_CXX20 void test7()
 {
     test(S("abcdefghijklmnopqrst"), 1, 9, str, str+1, S("a1klmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 1, 9, str, str+10, S("a1234567890klmnopqrst"));
@@ -906,7 +906,7 @@
 }
 
 template <class S>
-void test8()
+TEST_CONSTEXPR_CXX20 void test8()
 {
     test(S("abcdefghijklmnopqrst"), 10, 10, str, str+0, S("abcdefghij"));
     test(S("abcdefghijklmnopqrst"), 10, 10, str, str+0, S("abcdefghij"));
@@ -974,20 +974,28 @@
     test(S("abcdefghijklmnopqrst"), 20, 0, str, str+20, S("abcdefghijklmnopqrst12345678901234567890"));
 }
 
-int main(int, char**)
-{
-    {
+TEST_CONSTEXPR_CXX20 bool test_0() {
     typedef std::string S;
     test0<S>();
     test1<S>();
     test2<S>();
     test3<S>();
     test4<S>();
+    
+    return true;
+}
+
+TEST_CONSTEXPR_CXX20 bool test_1() {
+    typedef std::string S;
     test5<S>();
     test6<S>();
     test7<S>();
     test8<S>();
-    }
+
+    return true;
+}
+
+TEST_CONSTEXPR_CXX20 bool test_2() {
 #if TEST_STD_VER >= 11
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
@@ -996,14 +1004,27 @@
     test2<S>();
     test3<S>();
     test4<S>();
+    }
+#endif
+    return true;
+}
+
+TEST_CONSTEXPR_CXX20 bool test_3() {
+#if TEST_STD_VER >= 11
+    typedef std::string S;
     test5<S>();
     test6<S>();
     test7<S>();
     test8<S>();
-    }
 #endif
+
+    return true;
+}
+
+TEST_CONSTEXPR_CXX20 bool test_4() {
+    
 #ifndef TEST_HAS_NO_EXCEPTIONS
-    { // test iterator operations that throw
+    if (!TEST_IS_CONSTANT_EVALUATED) { // test iterator operations that throw
     typedef std::string S;
     typedef ThrowingIterator<char> TIter;
     typedef cpp17_input_iterator<TIter> IIter;
@@ -1051,5 +1072,22 @@
     assert(s == "EFGH");
     }
 
+    return true;
+}
+
+int main(int, char**) {
+  test_0();
+  test_1();
+  test_2();
+  test_3();
+  test_4();
+#if TEST_STD_VER > 17
+  static_assert(test_0());
+  static_assert(test_1());
+  static_assert(test_2());
+  static_assert(test_3());
+  static_assert(test_4());
+#endif
+
   return 0;
 }
diff --git a/libcxx/test/std/strings/basic.string/string.modifiers/string_replace/iter_iter_pointer_size.pass.cpp b/libcxx/test/std/strings/basic.string/string.modifiers/string_replace/iter_iter_pointer_size.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.modifiers/string_replace/iter_iter_pointer_size.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.modifiers/string_replace/iter_iter_pointer_size.pass.cpp
@@ -19,7 +19,7 @@
 #include "min_allocator.h"
 
 template <class S>
-void
+TEST_CONSTEXPR_CXX20 void
 test(S s, typename S::size_type pos1, typename S::size_type n1, const typename S::value_type* str,
      typename S::size_type n2, S expected)
 {
@@ -35,7 +35,7 @@
 }
 
 template <class S>
-void test0()
+TEST_CONSTEXPR_CXX20 void test0()
 {
     test(S(""), 0, 0, "", 0, S(""));
     test(S(""), 0, 0, "12345", 0, S(""));
@@ -140,7 +140,7 @@
 }
 
 template <class S>
-void test1()
+TEST_CONSTEXPR_CXX20 void test1()
 {
     test(S("abcde"), 1, 0, "12345", 4, S("a1234bcde"));
     test(S("abcde"), 1, 0, "12345", 5, S("a12345bcde"));
@@ -245,7 +245,7 @@
 }
 
 template <class S>
-void test2()
+TEST_CONSTEXPR_CXX20 void test2()
 {
     test(S("abcde"), 2, 1, "1234567890", 5, S("ab12345de"));
     test(S("abcde"), 2, 1, "1234567890", 9, S("ab123456789de"));
@@ -350,7 +350,7 @@
 }
 
 template <class S>
-void test3()
+TEST_CONSTEXPR_CXX20 void test3()
 {
     test(S("abcdefghij"), 0, 0, "12345678901234567890", 1, S("1abcdefghij"));
     test(S("abcdefghij"), 0, 0, "12345678901234567890", 10, S("1234567890abcdefghij"));
@@ -455,7 +455,7 @@
 }
 
 template <class S>
-void test4()
+TEST_CONSTEXPR_CXX20 void test4()
 {
     test(S("abcdefghij"), 1, 4, "", 0, S("afghij"));
     test(S("abcdefghij"), 1, 4, "12345", 0, S("afghij"));
@@ -560,7 +560,7 @@
 }
 
 template <class S>
-void test5()
+TEST_CONSTEXPR_CXX20 void test5()
 {
     test(S("abcdefghij"), 5, 4, "12345", 4, S("abcde1234j"));
     test(S("abcdefghij"), 5, 4, "12345", 5, S("abcde12345j"));
@@ -665,7 +665,7 @@
 }
 
 template <class S>
-void test6()
+TEST_CONSTEXPR_CXX20 void test6()
 {
     test(S("abcdefghijklmnopqrst"), 0, 1, "1234567890", 5, S("12345bcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 0, 1, "1234567890", 9, S("123456789bcdefghijklmnopqrst"));
@@ -770,7 +770,7 @@
 }
 
 template <class S>
-void test7()
+TEST_CONSTEXPR_CXX20 void test7()
 {
     test(S("abcdefghijklmnopqrst"), 1, 9, "12345678901234567890", 1, S("a1klmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 1, 9, "12345678901234567890", 10, S("a1234567890klmnopqrst"));
@@ -875,7 +875,7 @@
 }
 
 template <class S>
-void test8()
+TEST_CONSTEXPR_CXX20 void test8()
 {
     test(S("abcdefghijklmnopqrst"), 10, 10, "", 0, S("abcdefghij"));
     test(S("abcdefghijklmnopqrst"), 10, 10, "12345", 0, S("abcdefghij"));
@@ -943,20 +943,28 @@
     test(S("abcdefghijklmnopqrst"), 20, 0, "12345678901234567890", 20, S("abcdefghijklmnopqrst12345678901234567890"));
 }
 
-int main(int, char**)
-{
-    {
+TEST_CONSTEXPR_CXX20 bool test_0() {
     typedef std::string S;
     test0<S>();
     test1<S>();
     test2<S>();
     test3<S>();
     test4<S>();
+    
+    return true;
+}
+
+TEST_CONSTEXPR_CXX20 bool test_1() {
+    typedef std::string S;
     test5<S>();
     test6<S>();
     test7<S>();
     test8<S>();
-    }
+
+    return true;
+}
+
+TEST_CONSTEXPR_CXX20 bool test_2() {
 #if TEST_STD_VER >= 11
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
@@ -965,13 +973,24 @@
     test2<S>();
     test3<S>();
     test4<S>();
+    }
+#endif
+    return true;
+}
+
+TEST_CONSTEXPR_CXX20 bool test_3() {
+#if TEST_STD_VER >= 11
+    typedef std::string S;
     test5<S>();
     test6<S>();
     test7<S>();
     test8<S>();
-    }
 #endif
 
+    return true;
+}
+
+TEST_CONSTEXPR_CXX20 bool test_4() {
     { // test replacing into self
     typedef std::string S;
     S s_short = "123/";
@@ -988,5 +1007,22 @@
     assert(s_long == "Lorem ipsum dolor sit amet, consectetur/Lorem ipsum dolor sit amet, consectetur/");
     }
 
+    return true;
+}
+
+int main(int, char**) {
+  test_0();
+  test_1();
+  test_2();
+  test_3();
+  test_4();
+#if TEST_STD_VER > 17
+  static_assert(test_0());
+  static_assert(test_1());
+  static_assert(test_2());
+  static_assert(test_3());
+  static_assert(test_4());
+#endif
+
   return 0;
 }
diff --git a/libcxx/test/std/strings/basic.string/string.modifiers/string_swap/swap.pass.cpp b/libcxx/test/std/strings/basic.string/string.modifiers/string_swap/swap.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.modifiers/string_swap/swap.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.modifiers/string_swap/swap.pass.cpp
@@ -19,7 +19,7 @@
 #include "min_allocator.h"
 
 template <class S>
-void
+TEST_CONSTEXPR_CXX20 void
 test(S s1, S s2)
 {
     S s1_ = s1;
@@ -31,8 +31,7 @@
     assert(s2 == s1_);
 }
 
-int main(int, char**)
-{
+TEST_CONSTEXPR_CXX20 bool test() {
     {
     typedef std::string S;
     test(S(""), S(""));
@@ -74,5 +73,14 @@
     }
 #endif
 
+  return true;
+}
+
+int main() {
+  test();
+#if TEST_STD_VER > 17
+  static_assert(test());
+#endif
+
   return 0;
 }
diff --git a/libcxx/test/std/strings/basic.string/string.nonmembers/string.special/swap.pass.cpp b/libcxx/test/std/strings/basic.string/string.nonmembers/string.special/swap.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.nonmembers/string.special/swap.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.nonmembers/string.special/swap.pass.cpp
@@ -21,7 +21,7 @@
 #include "min_allocator.h"
 
 template <class S>
-void
+TEST_CONSTEXPR_CXX20 void
 test(S s1, S s2)
 {
     S s1_ = s1;
@@ -33,8 +33,7 @@
     assert(s2 == s1_);
 }
 
-int main(int, char**)
-{
+TEST_CONSTEXPR_CXX20 bool test() {
     {
     typedef std::string S;
     test(S(""), S(""));
@@ -75,6 +74,15 @@
     test(S("abcdefghijklmnopqrst"), S("12345678901234567890"));
     }
 #endif
+    
+  return true;
+}
+
+int main() {
+  test();
+#if TEST_STD_VER > 17
+  static_assert(test());
+#endif
 
   return 0;
 }
diff --git a/libcxx/test/std/strings/basic.string/string.nonmembers/string_op!=/pointer_string.pass.cpp b/libcxx/test/std/strings/basic.string/string.nonmembers/string_op!=/pointer_string.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.nonmembers/string_op!=/pointer_string.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.nonmembers/string_op!=/pointer_string.pass.cpp
@@ -18,14 +18,13 @@
 #include "min_allocator.h"
 
 template <class S>
-void
+TEST_CONSTEXPR_CXX20 void
 test(const typename S::value_type* lhs, const S& rhs, bool x)
 {
     assert((lhs != rhs) == x);
 }
 
-int main(int, char**)
-{
+TEST_CONSTEXPR_CXX20 bool test() {
     {
     typedef std::string S;
     test("", S(""), false);
@@ -67,5 +66,14 @@
     }
 #endif
 
+  return true;
+}
+
+int main() {
+  test();
+#if TEST_STD_VER > 17
+  static_assert(test());
+#endif
+
   return 0;
 }
diff --git a/libcxx/test/std/strings/basic.string/string.nonmembers/string_op!=/string_pointer.pass.cpp b/libcxx/test/std/strings/basic.string/string.nonmembers/string_op!=/string_pointer.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.nonmembers/string_op!=/string_pointer.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.nonmembers/string_op!=/string_pointer.pass.cpp
@@ -18,14 +18,13 @@
 #include "min_allocator.h"
 
 template <class S>
-void
+TEST_CONSTEXPR_CXX20 void
 test(const S& lhs, const typename S::value_type* rhs, bool x)
 {
     assert((lhs != rhs) == x);
 }
 
-int main(int, char**)
-{
+TEST_CONSTEXPR_CXX20 bool test() {
     {
     typedef std::string S;
     test(S(""), "", false);
@@ -67,5 +66,14 @@
     }
 #endif
 
+  return true;
+}
+
+int main() {
+  test();
+#if TEST_STD_VER > 17
+  static_assert(test());
+#endif
+
   return 0;
 }
diff --git a/libcxx/test/std/strings/basic.string/string.nonmembers/string_op!=/string_string.pass.cpp b/libcxx/test/std/strings/basic.string/string.nonmembers/string_op!=/string_string.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.nonmembers/string_op!=/string_string.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.nonmembers/string_op!=/string_string.pass.cpp
@@ -19,14 +19,13 @@
 #include "min_allocator.h"
 
 template <class S>
-void
+TEST_CONSTEXPR_CXX20 void
 test(const S& lhs, const S& rhs, bool x)
 {
     assert((lhs != rhs) == x);
 }
 
-int main(int, char**)
-{
+TEST_CONSTEXPR_CXX20 bool test() {
     {
     typedef std::string S;
     test(S(""), S(""), false);
@@ -68,5 +67,14 @@
     }
 #endif
 
+  return true;
+}
+
+int main() {
+  test();
+#if TEST_STD_VER > 17
+  static_assert(test());
+#endif
+
   return 0;
 }
diff --git a/libcxx/test/std/strings/basic.string/string.nonmembers/string_op!=/string_string_view.pass.cpp b/libcxx/test/std/strings/basic.string/string.nonmembers/string_op!=/string_string_view.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.nonmembers/string_op!=/string_string_view.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.nonmembers/string_op!=/string_string_view.pass.cpp
@@ -17,14 +17,13 @@
 #include "min_allocator.h"
 
 template <class S, class SV>
-void
+TEST_CONSTEXPR_CXX20 void
 test(const S& lhs, SV rhs, bool x)
 {
     assert((lhs != rhs) == x);
 }
 
-int main(int, char**)
-{
+TEST_CONSTEXPR_CXX20 bool test() {
     {
     typedef std::string S;
     typedef std::string SV;
@@ -68,5 +67,14 @@
     }
 #endif
 
+  return true;
+}
+
+int main() {
+  test();
+#if TEST_STD_VER > 17
+  static_assert(test());
+#endif
+
   return 0;
 }
diff --git a/libcxx/test/std/strings/basic.string/string.nonmembers/string_op!=/string_view_string.pass.cpp b/libcxx/test/std/strings/basic.string/string.nonmembers/string_op!=/string_view_string.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.nonmembers/string_op!=/string_view_string.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.nonmembers/string_op!=/string_view_string.pass.cpp
@@ -17,14 +17,13 @@
 #include "min_allocator.h"
 
 template <class S, class SV>
-void
+TEST_CONSTEXPR_CXX20 void
 test(SV lhs, const S& rhs, bool x)
 {
     assert((lhs != rhs) == x);
 }
 
-int main(int, char**)
-{
+TEST_CONSTEXPR_CXX20 bool test() {
     {
     typedef std::string S;
     typedef std::string_view SV;
@@ -68,5 +67,14 @@
     }
 #endif
 
+  return true;
+}
+
+int main() {
+  test();
+#if TEST_STD_VER > 17
+  static_assert(test());
+#endif
+
   return 0;
 }
diff --git a/libcxx/test/std/strings/basic.string/string.nonmembers/string_op+/char_string.pass.cpp b/libcxx/test/std/strings/basic.string/string.nonmembers/string_op+/char_string.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.nonmembers/string_op+/char_string.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.nonmembers/string_op+/char_string.pass.cpp
@@ -24,18 +24,18 @@
 #include "min_allocator.h"
 
 template <class S>
-void test0(typename S::value_type lhs, const S& rhs, const S& x) {
+TEST_CONSTEXPR_CXX20 void test0(typename S::value_type lhs, const S& rhs, const S& x) {
   assert(lhs + rhs == x);
 }
 
 #if TEST_STD_VER >= 11
 template <class S>
-void test1(typename S::value_type lhs, S&& rhs, const S& x) {
+TEST_CONSTEXPR_CXX20 void test1(typename S::value_type lhs, S&& rhs, const S& x) {
   assert(lhs + move(rhs) == x);
 }
 #endif
 
-int main(int, char**) {
+TEST_CONSTEXPR_CXX20 bool test() {
   {
     typedef std::string S;
     test0('a', S(""), S("a"));
@@ -52,9 +52,7 @@
     test1('a', S("12345678901234567890"), S("a12345678901234567890"));
   }
   {
-    typedef std::basic_string<char, std::char_traits<char>,
-                              min_allocator<char> >
-        S;
+    typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test0('a', S(""), S("a"));
     test0('a', S("12345"), S("a12345"));
     test0('a', S("1234567890"), S("a1234567890"));
@@ -67,5 +65,14 @@
   }
 #endif
 
+  return true;
+}
+
+int main() {
+  test();
+#if TEST_STD_VER > 17
+  static_assert(test());
+#endif
+
   return 0;
 }
diff --git a/libcxx/test/std/strings/basic.string/string.nonmembers/string_op+/pointer_string.pass.cpp b/libcxx/test/std/strings/basic.string/string.nonmembers/string_op+/pointer_string.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.nonmembers/string_op+/pointer_string.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.nonmembers/string_op+/pointer_string.pass.cpp
@@ -24,19 +24,19 @@
 #include "min_allocator.h"
 
 template <class S>
-void test0(const typename S::value_type* lhs, const S& rhs, const S& x) {
+TEST_CONSTEXPR_CXX20 void test0(const typename S::value_type* lhs, const S& rhs, const S& x) {
   assert(lhs + rhs == x);
 }
 
 #if TEST_STD_VER >= 11
 template <class S>
-void test1(const typename S::value_type* lhs, S&& rhs, const S& x) {
+TEST_CONSTEXPR_CXX20 void test1(const typename S::value_type* lhs, S&& rhs, const S& x) {
   assert(lhs + move(rhs) == x);
 }
 #endif
 
-int main(int, char**) {
-  {
+TEST_CONSTEXPR_CXX20 bool test() {
+    {
     typedef std::string S;
     test0("", S(""), S(""));
     test0("", S("12345"), S("12345"));
@@ -128,5 +128,14 @@
   }
 #endif
 
+  return true;
+}
+
+int main() {
+  test();
+#if TEST_STD_VER > 17
+  static_assert(test());
+#endif
+
   return 0;
 }
diff --git a/libcxx/test/std/strings/basic.string/string.nonmembers/string_op+/string_char.pass.cpp b/libcxx/test/std/strings/basic.string/string.nonmembers/string_op+/string_char.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.nonmembers/string_op+/string_char.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.nonmembers/string_op+/string_char.pass.cpp
@@ -24,18 +24,18 @@
 #include "min_allocator.h"
 
 template <class S>
-void test0(const S& lhs, typename S::value_type rhs, const S& x) {
+TEST_CONSTEXPR_CXX20 void test0(const S& lhs, typename S::value_type rhs, const S& x) {
   assert(lhs + rhs == x);
 }
 
 #if TEST_STD_VER >= 11
 template <class S>
-void test1(S&& lhs, typename S::value_type rhs, const S& x) {
+TEST_CONSTEXPR_CXX20 void test1(S&& lhs, typename S::value_type rhs, const S& x) {
   assert(move(lhs) + rhs == x);
 }
 #endif
 
-int main(int, char**) {
+TEST_CONSTEXPR_CXX20 bool test() {
   {
     typedef std::string S;
     test0(S(""), '1', S("1"));
@@ -52,9 +52,7 @@
     test1(S("abcdefghijklmnopqrst"), '1', S("abcdefghijklmnopqrst1"));
   }
   {
-    typedef std::basic_string<char, std::char_traits<char>,
-                              min_allocator<char> >
-        S;
+    typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test0(S(""), '1', S("1"));
     test0(S("abcde"), '1', S("abcde1"));
     test0(S("abcdefghij"), '1', S("abcdefghij1"));
@@ -67,5 +65,14 @@
   }
 #endif
 
+  return true;
+}
+
+int main() {
+  test();
+#if TEST_STD_VER > 17
+  static_assert(test());
+#endif
+
   return 0;
 }
diff --git a/libcxx/test/std/strings/basic.string/string.nonmembers/string_op+/string_pointer.pass.cpp b/libcxx/test/std/strings/basic.string/string.nonmembers/string_op+/string_pointer.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.nonmembers/string_op+/string_pointer.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.nonmembers/string_op+/string_pointer.pass.cpp
@@ -24,18 +24,18 @@
 #include "min_allocator.h"
 
 template <class S>
-void test0(const S& lhs, const typename S::value_type* rhs, const S& x) {
+TEST_CONSTEXPR_CXX20 void test0(const S& lhs, const typename S::value_type* rhs, const S& x) {
   assert(lhs + rhs == x);
 }
 
 #if TEST_STD_VER >= 11
 template <class S>
-void test1(S&& lhs, const typename S::value_type* rhs, const S& x) {
+TEST_CONSTEXPR_CXX20 void test1(S&& lhs, const typename S::value_type* rhs, const S& x) {
   assert(move(lhs) + rhs == x);
 }
 #endif
 
-int main(int, char**) {
+TEST_CONSTEXPR_CXX20 bool test() {
   {
     typedef std::string S;
     test0(S(""), "", S(""));
@@ -127,5 +127,14 @@
   }
 #endif
 
+  return true;
+}
+
+int main() {
+  test();
+#if TEST_STD_VER > 17
+  static_assert(test());
+#endif
+
   return 0;
 }
diff --git a/libcxx/test/std/strings/basic.string/string.nonmembers/string_op+/string_string.pass.cpp b/libcxx/test/std/strings/basic.string/string.nonmembers/string_op+/string_string.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.nonmembers/string_op+/string_string.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.nonmembers/string_op+/string_string.pass.cpp
@@ -36,29 +36,29 @@
 #include "min_allocator.h"
 
 template <class S>
-void test0(const S& lhs, const S& rhs, const S& x) {
+TEST_CONSTEXPR_CXX20 void test0(const S& lhs, const S& rhs, const S& x) {
   assert(lhs + rhs == x);
 }
 
 #if TEST_STD_VER >= 11
 template <class S>
-void test1(S&& lhs, const S& rhs, const S& x) {
+TEST_CONSTEXPR_CXX20 void test1(S&& lhs, const S& rhs, const S& x) {
   assert(move(lhs) + rhs == x);
 }
 
 template <class S>
-void test2(const S& lhs, S&& rhs, const S& x) {
+TEST_CONSTEXPR_CXX20 void test2(const S& lhs, S&& rhs, const S& x) {
   assert(lhs + move(rhs) == x);
 }
 
 template <class S>
-void test3(S&& lhs, S&& rhs, const S& x) {
+TEST_CONSTEXPR_CXX20 void test3(S&& lhs, S&& rhs, const S& x) {
   assert(move(lhs) + move(rhs) == x);
 }
 
 #endif
 
-int main(int, char**) {
+TEST_CONSTEXPR_CXX20 bool test() {
   {
     typedef std::string S;
     test0(S(""), S(""), S(""));
@@ -246,5 +246,14 @@
   }
 #endif // TEST_STD_VER >= 11
 
+  return true;
+}
+
+int main() {
+  test();
+#if TEST_STD_VER > 17
+  static_assert(test());
+#endif
+
   return 0;
 }
diff --git a/libcxx/test/std/strings/basic.string/string.nonmembers/string_operator==/pointer_string.pass.cpp b/libcxx/test/std/strings/basic.string/string.nonmembers/string_operator==/pointer_string.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.nonmembers/string_operator==/pointer_string.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.nonmembers/string_operator==/pointer_string.pass.cpp
@@ -18,14 +18,13 @@
 #include "min_allocator.h"
 
 template <class S>
-void
+TEST_CONSTEXPR_CXX20 void
 test(const typename S::value_type* lhs, const S& rhs, bool x)
 {
     assert((lhs == rhs) == x);
 }
 
-int main(int, char**)
-{
+TEST_CONSTEXPR_CXX20 bool test() {
     {
     typedef std::string S;
     test("", S(""), true);
@@ -67,5 +66,14 @@
     }
 #endif
 
+  return true;
+}
+
+int main() {
+  test();
+#if TEST_STD_VER > 17
+  static_assert(test());
+#endif
+
   return 0;
 }
diff --git a/libcxx/test/std/strings/basic.string/string.nonmembers/string_operator==/string_pointer.pass.cpp b/libcxx/test/std/strings/basic.string/string.nonmembers/string_operator==/string_pointer.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.nonmembers/string_operator==/string_pointer.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.nonmembers/string_operator==/string_pointer.pass.cpp
@@ -18,14 +18,13 @@
 #include "min_allocator.h"
 
 template <class S>
-void
+TEST_CONSTEXPR_CXX20 void
 test(const S& lhs, const typename S::value_type* rhs, bool x)
 {
     assert((lhs == rhs) == x);
 }
 
-int main(int, char**)
-{
+TEST_CONSTEXPR_CXX20 bool test() {
     {
     typedef std::string S;
     test(S(""), "", true);
@@ -67,5 +66,14 @@
     }
 #endif
 
+  return true;
+}
+
+int main() {
+  test();
+#if TEST_STD_VER > 17
+  static_assert(test());
+#endif
+
   return 0;
 }
diff --git a/libcxx/test/std/strings/basic.string/string.nonmembers/string_operator==/string_string_view.pass.cpp b/libcxx/test/std/strings/basic.string/string.nonmembers/string_operator==/string_string_view.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.nonmembers/string_operator==/string_string_view.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.nonmembers/string_operator==/string_string_view.pass.cpp
@@ -17,14 +17,13 @@
 #include "min_allocator.h"
 
 template <class S, class SV>
-void
+TEST_CONSTEXPR_CXX20 void
 test(const S& lhs, SV rhs, bool x)
 {
     assert((lhs == rhs) == x);
 }
 
-int main(int, char**)
-{
+TEST_CONSTEXPR_CXX20 bool test() {
     {
     typedef std::string S;
     typedef std::string_view SV;
@@ -68,5 +67,14 @@
     }
 #endif
 
+  return true;
+}
+
+int main() {
+  test();
+#if TEST_STD_VER > 17
+  static_assert(test());
+#endif
+
   return 0;
 }
diff --git a/libcxx/test/std/strings/basic.string/string.nonmembers/string_operator==/string_view_string.pass.cpp b/libcxx/test/std/strings/basic.string/string.nonmembers/string_operator==/string_view_string.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.nonmembers/string_operator==/string_view_string.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.nonmembers/string_operator==/string_view_string.pass.cpp
@@ -17,14 +17,13 @@
 #include "min_allocator.h"
 
 template <class S, class SV>
-void
+TEST_CONSTEXPR_CXX20 void
 test(SV lhs, const S& rhs, bool x)
 {
     assert((lhs == rhs) == x);
 }
 
-int main(int, char**)
-{
+TEST_CONSTEXPR_CXX20 bool test() {
     {
     typedef std::string S;
     typedef std::string_view SV;
@@ -67,6 +66,14 @@
     test(SV("abcdefghijklmnopqrst"), S("abcdefghijklmnopqrst"), true);
     }
 #endif
+  return true;
+}
+
+int main() {
+  test();
+#if TEST_STD_VER > 17
+  static_assert(test());
+#endif
 
   return 0;
 }
diff --git a/libcxx/test/std/strings/basic.string/string.nonmembers/string_opgt/pointer_string.pass.cpp b/libcxx/test/std/strings/basic.string/string.nonmembers/string_opgt/pointer_string.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.nonmembers/string_opgt/pointer_string.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.nonmembers/string_opgt/pointer_string.pass.cpp
@@ -18,14 +18,13 @@
 #include "min_allocator.h"
 
 template <class S>
-void
+TEST_CONSTEXPR_CXX20 void
 test(const typename S::value_type* lhs, const S& rhs, bool x)
 {
     assert((lhs > rhs) == x);
 }
 
-int main(int, char**)
-{
+TEST_CONSTEXPR_CXX20 bool test() {
     {
     typedef std::string S;
     test("", S(""), false);
@@ -67,5 +66,14 @@
     }
 #endif
 
+  return true;
+}
+
+int main() {
+  test();
+#if TEST_STD_VER > 17
+  static_assert(test());
+#endif
+
   return 0;
 }
diff --git a/libcxx/test/std/strings/basic.string/string.nonmembers/string_opgt/string_pointer.pass.cpp b/libcxx/test/std/strings/basic.string/string.nonmembers/string_opgt/string_pointer.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.nonmembers/string_opgt/string_pointer.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.nonmembers/string_opgt/string_pointer.pass.cpp
@@ -18,14 +18,13 @@
 #include "min_allocator.h"
 
 template <class S>
-void
+TEST_CONSTEXPR_CXX20 void
 test(const S& lhs, const typename S::value_type* rhs, bool x)
 {
     assert((lhs > rhs) == x);
 }
 
-int main(int, char**)
-{
+TEST_CONSTEXPR_CXX20 bool test() {
     {
     typedef std::string S;
     test(S(""), "", false);
@@ -66,6 +65,15 @@
     test(S("abcdefghijklmnopqrst"), "abcdefghijklmnopqrst", false);
     }
 #endif
+    
+  return true;
+}
+
+int main() {
+  test();
+#if TEST_STD_VER > 17
+  static_assert(test());
+#endif
 
   return 0;
 }
diff --git a/libcxx/test/std/strings/basic.string/string.nonmembers/string_opgt/string_string.pass.cpp b/libcxx/test/std/strings/basic.string/string.nonmembers/string_opgt/string_string.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.nonmembers/string_opgt/string_string.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.nonmembers/string_opgt/string_string.pass.cpp
@@ -19,14 +19,13 @@
 #include "min_allocator.h"
 
 template <class S>
-void
+TEST_CONSTEXPR_CXX20 void
 test(const S& lhs, const S& rhs, bool x)
 {
     assert((lhs > rhs) == x);
 }
 
-int main(int, char**)
-{
+TEST_CONSTEXPR_CXX20 bool test() {
     {
     typedef std::string S;
     test(S(""), S(""), false);
@@ -67,6 +66,15 @@
     test(S("abcdefghijklmnopqrst"), S("abcdefghijklmnopqrst"), false);
     }
 #endif
+    
+  return true;
+}
+
+int main() {
+  test();
+#if TEST_STD_VER > 17
+  static_assert(test());
+#endif
 
   return 0;
 }
diff --git a/libcxx/test/std/strings/basic.string/string.nonmembers/string_opgt/string_string_view.pass.cpp b/libcxx/test/std/strings/basic.string/string.nonmembers/string_opgt/string_string_view.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.nonmembers/string_opgt/string_string_view.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.nonmembers/string_opgt/string_string_view.pass.cpp
@@ -17,14 +17,13 @@
 #include "min_allocator.h"
 
 template <class S, class SV>
-void
+TEST_CONSTEXPR_CXX20 void
 test(const S& lhs, SV rhs, bool x)
 {
     assert((lhs > rhs) == x);
 }
 
-int main(int, char**)
-{
+TEST_CONSTEXPR_CXX20 bool test() {
     {
     typedef std::string S;
     typedef std::string_view SV;
@@ -67,6 +66,15 @@
     test(S("abcdefghijklmnopqrst"), SV("abcdefghijklmnopqrst"), false);
     }
 #endif
+    
+  return true;
+}
+
+int main() {
+  test();
+#if TEST_STD_VER > 17
+  static_assert(test());
+#endif
 
   return 0;
 }
diff --git a/libcxx/test/std/strings/basic.string/string.nonmembers/string_opgt/string_view_string.pass.cpp b/libcxx/test/std/strings/basic.string/string.nonmembers/string_opgt/string_view_string.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.nonmembers/string_opgt/string_view_string.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.nonmembers/string_opgt/string_view_string.pass.cpp
@@ -17,14 +17,13 @@
 #include "min_allocator.h"
 
 template <class S, class SV>
-void
+TEST_CONSTEXPR_CXX20 void
 test(SV lhs, const S& rhs, bool x)
 {
     assert((lhs > rhs) == x);
 }
 
-int main(int, char**)
-{
+TEST_CONSTEXPR_CXX20 bool test() {
     {
     typedef std::string S;
     typedef std::string_view SV;
@@ -67,6 +66,15 @@
     test(SV("abcdefghijklmnopqrst"), S("abcdefghijklmnopqrst"), false);
     }
 #endif
+    
+  return true;
+}
+
+int main() {
+  test();
+#if TEST_STD_VER > 17
+  static_assert(test());
+#endif
 
   return 0;
 }
diff --git a/libcxx/test/std/strings/basic.string/string.nonmembers/string_opgt=/pointer_string.pass.cpp b/libcxx/test/std/strings/basic.string/string.nonmembers/string_opgt=/pointer_string.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.nonmembers/string_opgt=/pointer_string.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.nonmembers/string_opgt=/pointer_string.pass.cpp
@@ -18,14 +18,13 @@
 #include "min_allocator.h"
 
 template <class S>
-void
+TEST_CONSTEXPR_CXX20 void
 test(const typename S::value_type* lhs, const S& rhs, bool x)
 {
     assert((lhs >= rhs) == x);
 }
 
-int main(int, char**)
-{
+TEST_CONSTEXPR_CXX20 bool test() {
     {
     typedef std::string S;
     test("", S(""), true);
@@ -66,6 +65,15 @@
     test("abcdefghijklmnopqrst", S("abcdefghijklmnopqrst"), true);
     }
 #endif
+    
+  return true;
+}
+
+int main() {
+  test();
+#if TEST_STD_VER > 17
+  static_assert(test());
+#endif
 
   return 0;
 }
diff --git a/libcxx/test/std/strings/basic.string/string.nonmembers/string_opgt=/string_pointer.pass.cpp b/libcxx/test/std/strings/basic.string/string.nonmembers/string_opgt=/string_pointer.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.nonmembers/string_opgt=/string_pointer.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.nonmembers/string_opgt=/string_pointer.pass.cpp
@@ -18,14 +18,13 @@
 #include "min_allocator.h"
 
 template <class S>
-void
+TEST_CONSTEXPR_CXX20 void
 test(const S& lhs, const typename S::value_type* rhs, bool x)
 {
     assert((lhs >= rhs) == x);
 }
 
-int main(int, char**)
-{
+TEST_CONSTEXPR_CXX20 bool test() {
     {
     typedef std::string S;
     test(S(""), "", true);
@@ -66,6 +65,15 @@
     test(S("abcdefghijklmnopqrst"), "abcdefghijklmnopqrst", true);
     }
 #endif
+    
+  return true;
+}
+
+int main() {
+  test();
+#if TEST_STD_VER > 17
+  static_assert(test());
+#endif
 
   return 0;
 }
diff --git a/libcxx/test/std/strings/basic.string/string.nonmembers/string_opgt=/string_string.pass.cpp b/libcxx/test/std/strings/basic.string/string.nonmembers/string_opgt=/string_string.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.nonmembers/string_opgt=/string_string.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.nonmembers/string_opgt=/string_string.pass.cpp
@@ -19,14 +19,13 @@
 #include "min_allocator.h"
 
 template <class S>
-void
+TEST_CONSTEXPR_CXX20 void
 test(const S& lhs, const S& rhs, bool x)
 {
     assert((lhs >= rhs) == x);
 }
 
-int main(int, char**)
-{
+TEST_CONSTEXPR_CXX20 bool test() {
     {
     typedef std::string S;
     test(S(""), S(""), true);
@@ -67,6 +66,15 @@
     test(S("abcdefghijklmnopqrst"), S("abcdefghijklmnopqrst"), true);
     }
 #endif
+    
+  return true;
+}
+
+int main() {
+  test();
+#if TEST_STD_VER > 17
+  static_assert(test());
+#endif
 
   return 0;
 }
diff --git a/libcxx/test/std/strings/basic.string/string.nonmembers/string_opgt=/string_string_view.pass.cpp b/libcxx/test/std/strings/basic.string/string.nonmembers/string_opgt=/string_string_view.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.nonmembers/string_opgt=/string_string_view.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.nonmembers/string_opgt=/string_string_view.pass.cpp
@@ -17,14 +17,13 @@
 #include "min_allocator.h"
 
 template <class S, class SV>
-void
+TEST_CONSTEXPR_CXX20 void
 test(const S& lhs, SV rhs, bool x)
 {
     assert((lhs >= rhs) == x);
 }
 
-int main(int, char**)
-{
+TEST_CONSTEXPR_CXX20 bool test() {
     {
     typedef std::string S;
     typedef std::string_view SV;
@@ -67,6 +66,15 @@
     test(S("abcdefghijklmnopqrst"), SV("abcdefghijklmnopqrst"), true);
     }
 #endif
+    
+  return true;
+}
+
+int main() {
+  test();
+#if TEST_STD_VER > 17
+  static_assert(test());
+#endif
 
   return 0;
 }
diff --git a/libcxx/test/std/strings/basic.string/string.nonmembers/string_opgt=/string_view_string.pass.cpp b/libcxx/test/std/strings/basic.string/string.nonmembers/string_opgt=/string_view_string.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.nonmembers/string_opgt=/string_view_string.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.nonmembers/string_opgt=/string_view_string.pass.cpp
@@ -17,14 +17,13 @@
 #include "min_allocator.h"
 
 template <class S, class SV>
-void
+TEST_CONSTEXPR_CXX20 void
 test(SV lhs, const S& rhs, bool x)
 {
     assert((lhs >= rhs) == x);
 }
 
-int main(int, char**)
-{
+TEST_CONSTEXPR_CXX20 bool test() {
     {
     typedef std::string S;
     typedef std::string_view SV;
@@ -67,6 +66,15 @@
     test(SV("abcdefghijklmnopqrst"), S("abcdefghijklmnopqrst"), true);
     }
 #endif
+    
+  return true;
+}
+
+int main() {
+  test();
+#if TEST_STD_VER > 17
+  static_assert(test());
+#endif
 
   return 0;
 }
diff --git a/libcxx/test/std/strings/basic.string/string.nonmembers/string_oplt/pointer_string.pass.cpp b/libcxx/test/std/strings/basic.string/string.nonmembers/string_oplt/pointer_string.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.nonmembers/string_oplt/pointer_string.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.nonmembers/string_oplt/pointer_string.pass.cpp
@@ -18,14 +18,13 @@
 #include "min_allocator.h"
 
 template <class S>
-void
+TEST_CONSTEXPR_CXX20 void
 test(const typename S::value_type* lhs, const S& rhs, bool x)
 {
     assert((lhs < rhs) == x);
 }
 
-int main(int, char**)
-{
+TEST_CONSTEXPR_CXX20 bool test() {
     {
     typedef std::string S;
     test("", S(""), false);
@@ -66,6 +65,15 @@
     test("abcdefghijklmnopqrst", S("abcdefghijklmnopqrst"), false);
     }
 #endif
+    
+  return true;
+}
+
+int main() {
+  test();
+#if TEST_STD_VER > 17
+  static_assert(test());
+#endif
 
   return 0;
 }
diff --git a/libcxx/test/std/strings/basic.string/string.nonmembers/string_oplt/string_pointer.pass.cpp b/libcxx/test/std/strings/basic.string/string.nonmembers/string_oplt/string_pointer.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.nonmembers/string_oplt/string_pointer.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.nonmembers/string_oplt/string_pointer.pass.cpp
@@ -18,14 +18,13 @@
 #include "min_allocator.h"
 
 template <class S>
-void
+TEST_CONSTEXPR_CXX20 void
 test(const S& lhs, const typename S::value_type* rhs, bool x)
 {
     assert((lhs < rhs) == x);
 }
 
-int main(int, char**)
-{
+TEST_CONSTEXPR_CXX20 bool test() {
     {
     typedef std::string S;
     test(S(""), "", false);
@@ -66,6 +65,15 @@
     test(S("abcdefghijklmnopqrst"), "abcdefghijklmnopqrst", false);
     }
 #endif
+    
+  return true;
+}
+
+int main() {
+  test();
+#if TEST_STD_VER > 17
+  static_assert(test());
+#endif
 
   return 0;
 }
diff --git a/libcxx/test/std/strings/basic.string/string.nonmembers/string_oplt/string_string.pass.cpp b/libcxx/test/std/strings/basic.string/string.nonmembers/string_oplt/string_string.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.nonmembers/string_oplt/string_string.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.nonmembers/string_oplt/string_string.pass.cpp
@@ -19,14 +19,13 @@
 #include "min_allocator.h"
 
 template <class S>
-void
+TEST_CONSTEXPR_CXX20 void
 test(const S& lhs, const S& rhs, bool x)
 {
     assert((lhs < rhs) == x);
 }
 
-int main(int, char**)
-{
+TEST_CONSTEXPR_CXX20 bool test() {
     {
     typedef std::string S;
     test(S(""), S(""), false);
@@ -67,6 +66,15 @@
     test(S("abcdefghijklmnopqrst"), S("abcdefghijklmnopqrst"), false);
     }
 #endif
+    
+  return true;
+}
+
+int main() {
+  test();
+#if TEST_STD_VER > 17
+  static_assert(test());
+#endif
 
   return 0;
 }
diff --git a/libcxx/test/std/strings/basic.string/string.nonmembers/string_oplt/string_string_view.pass.cpp b/libcxx/test/std/strings/basic.string/string.nonmembers/string_oplt/string_string_view.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.nonmembers/string_oplt/string_string_view.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.nonmembers/string_oplt/string_string_view.pass.cpp
@@ -17,14 +17,13 @@
 #include "min_allocator.h"
 
 template <class S, class SV>
-void
+TEST_CONSTEXPR_CXX20 void
 test(const S& lhs, SV rhs, bool x)
 {
     assert((lhs < rhs) == x);
 }
 
-int main(int, char**)
-{
+TEST_CONSTEXPR_CXX20 bool test() {
     {
     typedef std::string S;
     typedef std::string_view SV;
@@ -67,6 +66,15 @@
     test(S("abcdefghijklmnopqrst"), SV("abcdefghijklmnopqrst"), false);
     }
 #endif
+    
+  return true;
+}
+
+int main() {
+  test();
+#if TEST_STD_VER > 17
+  static_assert(test());
+#endif
 
   return 0;
 }
diff --git a/libcxx/test/std/strings/basic.string/string.nonmembers/string_oplt/string_view_string.pass.cpp b/libcxx/test/std/strings/basic.string/string.nonmembers/string_oplt/string_view_string.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.nonmembers/string_oplt/string_view_string.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.nonmembers/string_oplt/string_view_string.pass.cpp
@@ -17,14 +17,13 @@
 #include "min_allocator.h"
 
 template <class S, class SV>
-void
+TEST_CONSTEXPR_CXX20 void
 test(SV lhs, const S& rhs, bool x)
 {
     assert((lhs < rhs) == x);
 }
 
-int main(int, char**)
-{
+TEST_CONSTEXPR_CXX20 bool test() {
     {
     typedef std::string S;
     typedef std::string_view SV;
@@ -67,6 +66,15 @@
     test(SV("abcdefghijklmnopqrst"), S("abcdefghijklmnopqrst"), false);
     }
 #endif
+    
+  return true;
+}
+
+int main() {
+  test();
+#if TEST_STD_VER > 17
+  static_assert(test());
+#endif
 
   return 0;
 }
diff --git a/libcxx/test/std/strings/basic.string/string.nonmembers/string_oplt=/pointer_string.pass.cpp b/libcxx/test/std/strings/basic.string/string.nonmembers/string_oplt=/pointer_string.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.nonmembers/string_oplt=/pointer_string.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.nonmembers/string_oplt=/pointer_string.pass.cpp
@@ -18,14 +18,13 @@
 #include "min_allocator.h"
 
 template <class S>
-void
+TEST_CONSTEXPR_CXX20 void
 test(const typename S::value_type* lhs, const S& rhs, bool x)
 {
     assert((lhs <= rhs) == x);
 }
 
-int main(int, char**)
-{
+TEST_CONSTEXPR_CXX20 bool test() {
     {
     typedef std::string S;
     test("", S(""), true);
@@ -66,6 +65,15 @@
     test("abcdefghijklmnopqrst", S("abcdefghijklmnopqrst"), true);
     }
 #endif
+    
+  return true;
+}
+
+int main() {
+  test();
+#if TEST_STD_VER > 17
+  static_assert(test());
+#endif
 
   return 0;
 }
diff --git a/libcxx/test/std/strings/basic.string/string.nonmembers/string_oplt=/string_pointer.pass.cpp b/libcxx/test/std/strings/basic.string/string.nonmembers/string_oplt=/string_pointer.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.nonmembers/string_oplt=/string_pointer.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.nonmembers/string_oplt=/string_pointer.pass.cpp
@@ -18,14 +18,13 @@
 #include "min_allocator.h"
 
 template <class S>
-void
+TEST_CONSTEXPR_CXX20 void
 test(const S& lhs, const typename S::value_type* rhs, bool x)
 {
     assert((lhs <= rhs) == x);
 }
 
-int main(int, char**)
-{
+TEST_CONSTEXPR_CXX20 bool test() {
     {
     typedef std::string S;
     test(S(""), "", true);
@@ -66,6 +65,15 @@
     test(S("abcdefghijklmnopqrst"), "abcdefghijklmnopqrst", true);
     }
 #endif
+    
+  return true;
+}
+
+int main() {
+  test();
+#if TEST_STD_VER > 17
+  static_assert(test());
+#endif
 
   return 0;
 }
diff --git a/libcxx/test/std/strings/basic.string/string.nonmembers/string_oplt=/string_string.pass.cpp b/libcxx/test/std/strings/basic.string/string.nonmembers/string_oplt=/string_string.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.nonmembers/string_oplt=/string_string.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.nonmembers/string_oplt=/string_string.pass.cpp
@@ -19,14 +19,13 @@
 #include "min_allocator.h"
 
 template <class S>
-void
+TEST_CONSTEXPR_CXX20 void
 test(const S& lhs, const S& rhs, bool x)
 {
     assert((lhs <= rhs) == x);
 }
 
-int main(int, char**)
-{
+TEST_CONSTEXPR_CXX20 bool test() {
     {
     typedef std::string S;
     test(S(""), S(""), true);
@@ -67,6 +66,15 @@
     test(S("abcdefghijklmnopqrst"), S("abcdefghijklmnopqrst"), true);
     }
 #endif
+    
+  return true;
+}
+
+int main() {
+  test();
+#if TEST_STD_VER > 17
+  static_assert(test());
+#endif
 
   return 0;
 }
diff --git a/libcxx/test/std/strings/basic.string/string.nonmembers/string_oplt=/string_string_view.pass.cpp b/libcxx/test/std/strings/basic.string/string.nonmembers/string_oplt=/string_string_view.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.nonmembers/string_oplt=/string_string_view.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.nonmembers/string_oplt=/string_string_view.pass.cpp
@@ -17,14 +17,13 @@
 #include "min_allocator.h"
 
 template <class S, class SV>
-void
+TEST_CONSTEXPR_CXX20 void
 test(const S& lhs, SV rhs, bool x)
 {
     assert((lhs <= rhs) == x);
 }
 
-int main(int, char**)
-{
+TEST_CONSTEXPR_CXX20 bool test() {
     {
     typedef std::string S;
     typedef std::string_view SV;
@@ -67,6 +66,15 @@
     test(S("abcdefghijklmnopqrst"), SV("abcdefghijklmnopqrst"), true);
     }
 #endif
+    
+  return true;
+}
+
+int main() {
+  test();
+#if TEST_STD_VER > 17
+  static_assert(test());
+#endif
 
   return 0;
 }
diff --git a/libcxx/test/std/strings/basic.string/string.nonmembers/string_oplt=/string_view_string.pass.cpp b/libcxx/test/std/strings/basic.string/string.nonmembers/string_oplt=/string_view_string.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.nonmembers/string_oplt=/string_view_string.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.nonmembers/string_oplt=/string_view_string.pass.cpp
@@ -17,14 +17,13 @@
 #include "min_allocator.h"
 
 template <class S, class SV>
-void
+TEST_CONSTEXPR_CXX20 void
 test(SV lhs, const S& rhs, bool x)
 {
     assert((lhs <= rhs) == x);
 }
 
-int main(int, char**)
-{
+TEST_CONSTEXPR_CXX20 bool test() {
     {
     typedef std::string S;
     typedef std::string_view SV;
@@ -67,6 +66,15 @@
     test(SV("abcdefghijklmnopqrst"), S("abcdefghijklmnopqrst"), true);
     }
 #endif
+    
+  return true;
+}
+
+int main() {
+  test();
+#if TEST_STD_VER > 17
+  static_assert(test());
+#endif
 
   return 0;
 }
diff --git a/libcxx/test/std/strings/basic.string/string.ops/string.accessors/c_str.pass.cpp b/libcxx/test/std/strings/basic.string/string.ops/string.accessors/c_str.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.ops/string.accessors/c_str.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.ops/string.accessors/c_str.pass.cpp
@@ -17,7 +17,7 @@
 #include "min_allocator.h"
 
 template <class S>
-void
+TEST_CONSTEXPR_CXX20 void
 test(const S& s)
 {
     typedef typename S::traits_type T;
@@ -31,8 +31,7 @@
         assert(T::eq(str[0], typename S::value_type()));
 }
 
-int main(int, char**)
-{
+TEST_CONSTEXPR_CXX20 bool test() {
     {
     typedef std::string S;
     test(S(""));
@@ -49,6 +48,15 @@
     test(S("abcdefghijklmnopqrst"));
     }
 #endif
+    
+  return true;
+}
+
+int main() {
+  test();
+#if TEST_STD_VER > 17
+  static_assert(test());
+#endif
 
   return 0;
 }
diff --git a/libcxx/test/std/strings/basic.string/string.ops/string.accessors/data.pass.cpp b/libcxx/test/std/strings/basic.string/string.ops/string.accessors/data.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.ops/string.accessors/data.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.ops/string.accessors/data.pass.cpp
@@ -18,7 +18,7 @@
 #include "min_allocator.h"
 
 template <class S>
-void
+TEST_CONSTEXPR_CXX20 void
 test_const(const S& s)
 {
     typedef typename S::traits_type T;
@@ -33,7 +33,7 @@
 }
 
 template <class S>
-void
+TEST_CONSTEXPR_CXX20 void
 test_nonconst(S& s)
 {
     typedef typename S::traits_type T;
@@ -47,8 +47,7 @@
         assert(T::eq(str[0], typename S::value_type()));
 }
 
-int main(int, char**)
-{
+TEST_CONSTEXPR_CXX20 bool test() {
     {
     typedef std::string S;
     test_const(S(""));
@@ -74,6 +73,15 @@
     S s4("abcdefghijklmnopqrst"); test_nonconst(s4);
     }
 #endif
+    
+  return true;
+}
+
+int main() {
+  test();
+#if TEST_STD_VER > 17
+  static_assert(test());
+#endif
 
   return 0;
 }
diff --git a/libcxx/test/std/strings/basic.string/string.ops/string.accessors/get_allocator.pass.cpp b/libcxx/test/std/strings/basic.string/string.ops/string.accessors/get_allocator.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.ops/string.accessors/get_allocator.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.ops/string.accessors/get_allocator.pass.cpp
@@ -18,14 +18,13 @@
 #include "min_allocator.h"
 
 template <class S>
-void
+TEST_CONSTEXPR_CXX20 void
 test(const S& s, const typename S::allocator_type& a)
 {
     assert(s.get_allocator() == a);
 }
 
-int main(int, char**)
-{
+TEST_CONSTEXPR_CXX20 bool test() {
     {
     typedef test_allocator<char> A;
     typedef std::basic_string<char, std::char_traits<char>, A> S;
@@ -44,6 +43,15 @@
     test(S("abcdefghijklmnopqrst", A()), A());
     }
 #endif
+    
+  return true;
+}
+
+int main() {
+  test();
+#if TEST_STD_VER > 17
+  static_assert(test());
+#endif
 
   return 0;
 }
diff --git a/libcxx/test/std/strings/basic.string/string.ops/string_compare/pointer.pass.cpp b/libcxx/test/std/strings/basic.string/string.ops/string_compare/pointer.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.ops/string_compare/pointer.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.ops/string_compare/pointer.pass.cpp
@@ -16,7 +16,7 @@
 #include "test_macros.h"
 #include "min_allocator.h"
 
-int sign(int x)
+TEST_CONSTEXPR_CXX20 int sign(int x)
 {
     if (x == 0)
         return 0;
@@ -26,15 +26,14 @@
 }
 
 template <class S>
-void
+TEST_CONSTEXPR_CXX20 void
 test(const S& s, const typename S::value_type* str, int x)
 {
     LIBCPP_ASSERT_NOEXCEPT(s.compare(str));
     assert(sign(s.compare(str)) == sign(x));
 }
 
-int main(int, char**)
-{
+TEST_CONSTEXPR_CXX20 bool test() {
     {
     typedef std::string S;
     test(S(""), "", 0);
@@ -75,6 +74,15 @@
     test(S("abcdefghijklmnopqrst"), "abcdefghijklmnopqrst", 0);
     }
 #endif
+    
+  return true;
+}
+
+int main() {
+  test();
+#if TEST_STD_VER > 17
+  static_assert(test());
+#endif
 
   return 0;
 }
diff --git a/libcxx/test/std/strings/basic.string/string.ops/string_compare/size_size_T_size_size.pass.cpp b/libcxx/test/std/strings/basic.string/string.ops/string_compare/size_size_T_size_size.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.ops/string_compare/size_size_T_size_size.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.ops/string_compare/size_size_T_size_size.pass.cpp
@@ -22,7 +22,7 @@
 
 #include "test_macros.h"
 
-int sign(int x)
+TEST_CONSTEXPR_CXX20 int sign(int x)
 {
     if (x == 0)
         return 0;
@@ -32,7 +32,7 @@
 }
 
 template <class S, class SV>
-void
+TEST_CONSTEXPR_CXX20 void
 test(const S& s, typename S::size_type pos1, typename S::size_type n1,
      SV sv,      typename S::size_type pos2, typename S::size_type n2, int x)
 {
@@ -40,7 +40,7 @@
     if (pos1 <= s.size() && pos2 <= sv.size())
         assert(sign(s.compare(pos1, n1, sv, pos2, n2)) == sign(x));
 #ifndef TEST_HAS_NO_EXCEPTIONS
-    else
+    else if (!TEST_IS_CONSTANT_EVALUATED)
     {
         try
         {
@@ -56,7 +56,7 @@
 }
 
 template <class S, class SV>
-void
+TEST_CONSTEXPR_CXX20 void
 test_npos(const S& s, typename S::size_type pos1, typename S::size_type n1,
           SV sv,      typename S::size_type pos2, int x)
 {
@@ -64,7 +64,7 @@
     if (pos1 <= s.size() && pos2 <= sv.size())
         assert(sign(s.compare(pos1, n1, sv, pos2)) == sign(x));
 #ifndef TEST_HAS_NO_EXCEPTIONS
-    else
+    else if (!TEST_IS_CONSTANT_EVALUATED)
     {
         try
         {
@@ -80,7 +80,7 @@
 }
 
 template <class S, class SV>
-void test0()
+TEST_CONSTEXPR_CXX20 void test0()
 {
     test(S(""), 0, 0, SV(""), 0, 0, 0);
     test(S(""), 0, 0, SV(""), 0, 1, 0);
@@ -185,7 +185,7 @@
 }
 
 template <class S, class SV>
-void test1()
+TEST_CONSTEXPR_CXX20 void test1()
 {
     test(S(""), 0, 1, SV("abcdefghij"), 0, 0, 0);
     test(S(""), 0, 1, SV("abcdefghij"), 0, 1, -1);
@@ -290,7 +290,7 @@
 }
 
 template <class S, class SV>
-void test2()
+TEST_CONSTEXPR_CXX20 void test2()
 {
     test(S(""), 1, 0, SV("abcdefghijklmnopqrst"), 0, 10, 0);
     test(S(""), 1, 0, SV("abcdefghijklmnopqrst"), 0, 19, 0);
@@ -395,7 +395,7 @@
 }
 
 template <class S, class SV>
-void test3()
+TEST_CONSTEXPR_CXX20 void test3()
 {
     test(S("abcde"), 0, 1, SV("abcde"), 0, 1, 0);
     test(S("abcde"), 0, 1, SV("abcde"), 0, 2, -1);
@@ -500,7 +500,7 @@
 }
 
 template <class S, class SV>
-void test4()
+TEST_CONSTEXPR_CXX20 void test4()
 {
     test(S("abcde"), 0, 2, SV("abcdefghij"), 0, 10, -8);
     test(S("abcde"), 0, 2, SV("abcdefghij"), 0, 11, -8);
@@ -605,7 +605,7 @@
 }
 
 template <class S, class SV>
-void test5()
+TEST_CONSTEXPR_CXX20 void test5()
 {
     test(S("abcde"), 0, 4, SV("abcdefghijklmnopqrst"), 1, 0, 4);
     test(S("abcde"), 0, 4, SV("abcdefghijklmnopqrst"), 1, 1, -1);
@@ -710,7 +710,7 @@
 }
 
 template <class S, class SV>
-void test6()
+TEST_CONSTEXPR_CXX20 void test6()
 {
     test(S("abcde"), 0, 6, SV("abcde"), 0, 6, 0);
     test(S("abcde"), 0, 6, SV("abcde"), 1, 0, 5);
@@ -815,7 +815,7 @@
 }
 
 template <class S, class SV>
-void test7()
+TEST_CONSTEXPR_CXX20 void test7()
 {
     test(S("abcde"), 1, 0, SV("abcdefghij"), 1, 4, -4);
     test(S("abcde"), 1, 0, SV("abcdefghij"), 1, 8, -8);
@@ -920,7 +920,7 @@
 }
 
 template <class S, class SV>
-void test8()
+TEST_CONSTEXPR_CXX20 void test8()
 {
     test(S("abcde"), 1, 1, SV("abcdefghijklmnopqrst"), 1, 19, -18);
     test(S("abcde"), 1, 1, SV("abcdefghijklmnopqrst"), 1, 20, -18);
@@ -1025,7 +1025,7 @@
 }
 
 template <class S, class SV>
-void test9()
+TEST_CONSTEXPR_CXX20 void test9()
 {
     test(S("abcde"), 1, 3, SV("abcde"), 1, 3, 0);
     test(S("abcde"), 1, 3, SV("abcde"), 1, 4, -1);
@@ -1130,7 +1130,7 @@
 }
 
 template <class S, class SV>
-void test10()
+TEST_CONSTEXPR_CXX20 void test10()
 {
     test(S("abcde"), 1, 4, SV("abcdefghij"), 5, 0, 4);
     test(S("abcde"), 1, 4, SV("abcdefghij"), 5, 1, -4);
@@ -1235,7 +1235,7 @@
 }
 
 template <class S, class SV>
-void test11()
+TEST_CONSTEXPR_CXX20 void test11()
 {
     test(S("abcde"), 1, 5, SV("abcdefghijklmnopqrst"), 10, 5, -9);
     test(S("abcde"), 1, 5, SV("abcdefghijklmnopqrst"), 10, 9, -9);
@@ -1340,7 +1340,7 @@
 }
 
 template <class S, class SV>
-void test12()
+TEST_CONSTEXPR_CXX20 void test12()
 {
     test(S("abcde"), 2, 1, SV("abcde"), 2, 1, 0);
     test(S("abcde"), 2, 1, SV("abcde"), 2, 2, -1);
@@ -1445,7 +1445,7 @@
 }
 
 template <class S, class SV>
-void test13()
+TEST_CONSTEXPR_CXX20 void test13()
 {
     test(S("abcde"), 2, 2, SV("abcdefghij"), 5, 5, -3);
     test(S("abcde"), 2, 2, SV("abcdefghij"), 5, 6, -3);
@@ -1550,7 +1550,7 @@
 }
 
 template <class S, class SV>
-void test14()
+TEST_CONSTEXPR_CXX20 void test14()
 {
     test(S("abcde"), 2, 3, SV("abcdefghijklmnopqrst"), 19, 0, 3);
     test(S("abcde"), 2, 3, SV("abcdefghijklmnopqrst"), 19, 1, -17);
@@ -1655,7 +1655,7 @@
 }
 
 template <class S, class SV>
-void test15()
+TEST_CONSTEXPR_CXX20 void test15()
 {
     test(S("abcde"), 4, 0, SV("abcde"), 4, 0, 0);
     test(S("abcde"), 4, 0, SV("abcde"), 4, 1, -1);
@@ -1760,7 +1760,7 @@
 }
 
 template <class S, class SV>
-void test16()
+TEST_CONSTEXPR_CXX20 void test16()
 {
     test(S("abcde"), 4, 1, SV("abcdefghij"), 9, 2, -5);
     test(S("abcde"), 4, 1, SV("abcdefghij"), 10, 0, 1);
@@ -1865,7 +1865,7 @@
 }
 
 template <class S, class SV>
-void test17()
+TEST_CONSTEXPR_CXX20 void test17()
 {
     test(S("abcde"), 4, 2, SV("abcdefghijklmnopqrst"), 20, 1, 1);
     test(S("abcde"), 4, 2, SV("abcdefghijklmnopqrst"), 21, 0, 0);
@@ -1970,7 +1970,7 @@
 }
 
 template <class S, class SV>
-void test18()
+TEST_CONSTEXPR_CXX20 void test18()
 {
     test(S("abcde"), 5, 1, SV("abcde"), 5, 1, 0);
     test(S("abcde"), 5, 1, SV("abcde"), 6, 0, 0);
@@ -2075,7 +2075,7 @@
 }
 
 template <class S, class SV>
-void test19()
+TEST_CONSTEXPR_CXX20 void test19()
 {
     test(S("abcde"), 6, 0, SV("abcdefghijklmnopqrst"), 0, 0, 0);
     test(S("abcde"), 6, 0, SV("abcdefghijklmnopqrst"), 0, 1, 0);
@@ -2180,7 +2180,7 @@
 }
 
 template <class S, class SV>
-void test20()
+TEST_CONSTEXPR_CXX20 void test20()
 {
     test(S("abcdefghij"), 0, 1, SV(""), 1, 0, 0);
     test(S("abcdefghij"), 0, 1, SV("abcde"), 0, 0, 1);
@@ -2285,7 +2285,7 @@
 }
 
 template <class S, class SV>
-void test21()
+TEST_CONSTEXPR_CXX20 void test21()
 {
     test(S("abcdefghij"), 0, 5, SV("abcdefghij"), 0, 5, 0);
     test(S("abcdefghij"), 0, 5, SV("abcdefghij"), 0, 9, -4);
@@ -2390,7 +2390,7 @@
 }
 
 template <class S, class SV>
-void test22()
+TEST_CONSTEXPR_CXX20 void test22()
 {
     test(S("abcdefghij"), 0, 9, SV("abcdefghijklmnopqrst"), 0, 20, -11);
     test(S("abcdefghij"), 0, 9, SV("abcdefghijklmnopqrst"), 0, 21, -11);
@@ -2495,7 +2495,7 @@
 }
 
 template <class S, class SV>
-void test23()
+TEST_CONSTEXPR_CXX20 void test23()
 {
     test(S("abcdefghij"), 0, 11, SV("abcde"), 0, 4, 6);
     test(S("abcdefghij"), 0, 11, SV("abcde"), 0, 5, 5);
@@ -2600,7 +2600,7 @@
 }
 
 template <class S, class SV>
-void test24()
+TEST_CONSTEXPR_CXX20 void test24()
 {
     test(S("abcdefghij"), 1, 0, SV("abcdefghij"), 1, 0, 0);
     test(S("abcdefghij"), 1, 0, SV("abcdefghij"), 1, 1, -1);
@@ -2705,7 +2705,7 @@
 }
 
 template <class S, class SV>
-void test25()
+TEST_CONSTEXPR_CXX20 void test25()
 {
     test(S("abcdefghij"), 1, 1, SV("abcdefghijklmnopqrst"), 1, 9, -8);
     test(S("abcdefghij"), 1, 1, SV("abcdefghijklmnopqrst"), 1, 18, -17);
@@ -2810,7 +2810,7 @@
 }
 
 template <class S, class SV>
-void test26()
+TEST_CONSTEXPR_CXX20 void test26()
 {
     test(S("abcdefghij"), 1, 8, SV("abcde"), 1, 1, 7);
     test(S("abcdefghij"), 1, 8, SV("abcde"), 1, 2, 6);
@@ -2915,7 +2915,7 @@
 }
 
 template <class S, class SV>
-void test27()
+TEST_CONSTEXPR_CXX20 void test27()
 {
     test(S("abcdefghij"), 1, 9, SV("abcdefghij"), 1, 9, 0);
     test(S("abcdefghij"), 1, 9, SV("abcdefghij"), 1, 10, 0);
@@ -3020,7 +3020,7 @@
 }
 
 template <class S, class SV>
-void test28()
+TEST_CONSTEXPR_CXX20 void test28()
 {
     test(S("abcdefghij"), 1, 10, SV("abcdefghijklmnopqrst"), 10, 0, 9);
     test(S("abcdefghij"), 1, 10, SV("abcdefghijklmnopqrst"), 10, 1, -9);
@@ -3125,7 +3125,7 @@
 }
 
 template <class S, class SV>
-void test29()
+TEST_CONSTEXPR_CXX20 void test29()
 {
     test(S("abcdefghij"), 5, 1, SV("abcde"), 1, 5, 4);
     test(S("abcdefghij"), 5, 1, SV("abcde"), 2, 0, 1);
@@ -3230,7 +3230,7 @@
 }
 
 template <class S, class SV>
-void test30()
+TEST_CONSTEXPR_CXX20 void test30()
 {
     test(S("abcdefghij"), 5, 2, SV("abcdefghij"), 5, 2, 0);
     test(S("abcdefghij"), 5, 2, SV("abcdefghij"), 5, 4, -2);
@@ -3335,7 +3335,7 @@
 }
 
 template <class S, class SV>
-void test31()
+TEST_CONSTEXPR_CXX20 void test31()
 {
     test(S("abcdefghij"), 5, 4, SV("abcdefghijklmnopqrst"), 10, 10, -5);
     test(S("abcdefghij"), 5, 4, SV("abcdefghijklmnopqrst"), 10, 11, -5);
@@ -3440,7 +3440,7 @@
 }
 
 template <class S, class SV>
-void test32()
+TEST_CONSTEXPR_CXX20 void test32()
 {
     test(S("abcdefghij"), 5, 6, SV("abcde"), 2, 3, 3);
     test(S("abcdefghij"), 5, 6, SV("abcde"), 2, 4, 3);
@@ -3545,7 +3545,7 @@
 }
 
 template <class S, class SV>
-void test33()
+TEST_CONSTEXPR_CXX20 void test33()
 {
     test(S("abcdefghij"), 9, 0, SV("abcdefghij"), 9, 0, 0);
     test(S("abcdefghij"), 9, 0, SV("abcdefghij"), 9, 1, -1);
@@ -3650,7 +3650,7 @@
 }
 
 template <class S, class SV>
-void test34()
+TEST_CONSTEXPR_CXX20 void test34()
 {
     test(S("abcdefghij"), 9, 1, SV("abcdefghijklmnopqrst"), 19, 2, -10);
     test(S("abcdefghij"), 9, 1, SV("abcdefghijklmnopqrst"), 20, 0, 1);
@@ -3755,7 +3755,7 @@
 }
 
 template <class S, class SV>
-void test35()
+TEST_CONSTEXPR_CXX20 void test35()
 {
     test(S("abcdefghij"), 10, 0, SV("abcde"), 4, 2, -1);
     test(S("abcdefghij"), 10, 0, SV("abcde"), 5, 0, 0);
@@ -3860,7 +3860,7 @@
 }
 
 template <class S, class SV>
-void test36()
+TEST_CONSTEXPR_CXX20 void test36()
 {
     test(S("abcdefghij"), 10, 1, SV("abcdefghij"), 10, 1, 0);
     test(S("abcdefghij"), 10, 1, SV("abcdefghij"), 11, 0, 0);
@@ -3965,7 +3965,7 @@
 }
 
 template <class S, class SV>
-void test37()
+TEST_CONSTEXPR_CXX20 void test37()
 {
     test(S("abcdefghijklmnopqrst"), 0, 0, SV(""), 0, 0, 0);
     test(S("abcdefghijklmnopqrst"), 0, 0, SV(""), 0, 1, 0);
@@ -4070,7 +4070,7 @@
 }
 
 template <class S, class SV>
-void test38()
+TEST_CONSTEXPR_CXX20 void test38()
 {
     test(S("abcdefghijklmnopqrst"), 0, 1, SV("abcdefghij"), 0, 0, 1);
     test(S("abcdefghijklmnopqrst"), 0, 1, SV("abcdefghij"), 0, 1, 0);
@@ -4175,7 +4175,7 @@
 }
 
 template <class S, class SV>
-void test39()
+TEST_CONSTEXPR_CXX20 void test39()
 {
     test(S("abcdefghijklmnopqrst"), 0, 10, SV("abcdefghijklmnopqrst"), 0, 10, 0);
     test(S("abcdefghijklmnopqrst"), 0, 10, SV("abcdefghijklmnopqrst"), 0, 19, -9);
@@ -4280,7 +4280,7 @@
 }
 
 template <class S, class SV>
-void test40()
+TEST_CONSTEXPR_CXX20 void test40()
 {
     test(S("abcdefghijklmnopqrst"), 0, 20, SV("abcde"), 0, 1, 19);
     test(S("abcdefghijklmnopqrst"), 0, 20, SV("abcde"), 0, 2, 18);
@@ -4385,7 +4385,7 @@
 }
 
 template <class S, class SV>
-void test41()
+TEST_CONSTEXPR_CXX20 void test41()
 {
     test(S("abcdefghijklmnopqrst"), 0, 21, SV("abcdefghij"), 0, 10, 10);
     test(S("abcdefghijklmnopqrst"), 0, 21, SV("abcdefghij"), 0, 11, 10);
@@ -4490,7 +4490,7 @@
 }
 
 template <class S, class SV>
-void test42()
+TEST_CONSTEXPR_CXX20 void test42()
 {
     test(S("abcdefghijklmnopqrst"), 1, 0, SV("abcdefghijklmnopqrst"), 1, 0, 0);
     test(S("abcdefghijklmnopqrst"), 1, 0, SV("abcdefghijklmnopqrst"), 1, 1, -1);
@@ -4595,7 +4595,7 @@
 }
 
 template <class S, class SV>
-void test43()
+TEST_CONSTEXPR_CXX20 void test43()
 {
     test(S("abcdefghijklmnopqrst"), 1, 9, SV("abcde"), 0, 6, 1);
     test(S("abcdefghijklmnopqrst"), 1, 9, SV("abcde"), 1, 0, 9);
@@ -4700,7 +4700,7 @@
 }
 
 template <class S, class SV>
-void test44()
+TEST_CONSTEXPR_CXX20 void test44()
 {
     test(S("abcdefghijklmnopqrst"), 1, 18, SV("abcdefghij"), 1, 4, 14);
     test(S("abcdefghijklmnopqrst"), 1, 18, SV("abcdefghij"), 1, 8, 10);
@@ -4805,7 +4805,7 @@
 }
 
 template <class S, class SV>
-void test45()
+TEST_CONSTEXPR_CXX20 void test45()
 {
     test(S("abcdefghijklmnopqrst"), 1, 19, SV("abcdefghijklmnopqrst"), 1, 19, 0);
     test(S("abcdefghijklmnopqrst"), 1, 19, SV("abcdefghijklmnopqrst"), 1, 20, 0);
@@ -4910,7 +4910,7 @@
 }
 
 template <class S, class SV>
-void test46()
+TEST_CONSTEXPR_CXX20 void test46()
 {
     test(S("abcdefghijklmnopqrst"), 10, 0, SV("abcde"), 1, 3, -3);
     test(S("abcdefghijklmnopqrst"), 10, 0, SV("abcde"), 1, 4, -4);
@@ -5015,7 +5015,7 @@
 }
 
 template <class S, class SV>
-void test47()
+TEST_CONSTEXPR_CXX20 void test47()
 {
     test(S("abcdefghijklmnopqrst"), 10, 1, SV("abcdefghij"), 5, 0, 1);
     test(S("abcdefghijklmnopqrst"), 10, 1, SV("abcdefghij"), 5, 1, 5);
@@ -5120,7 +5120,7 @@
 }
 
 template <class S, class SV>
-void test48()
+TEST_CONSTEXPR_CXX20 void test48()
 {
     test(S("abcdefghijklmnopqrst"), 10, 5, SV("abcdefghijklmnopqrst"), 10, 5, 0);
     test(S("abcdefghijklmnopqrst"), 10, 5, SV("abcdefghijklmnopqrst"), 10, 9, -4);
@@ -5225,7 +5225,7 @@
 }
 
 template <class S, class SV>
-void test49()
+TEST_CONSTEXPR_CXX20 void test49()
 {
     test(S("abcdefghijklmnopqrst"), 10, 10, SV("abcde"), 2, 1, 8);
     test(S("abcdefghijklmnopqrst"), 10, 10, SV("abcde"), 2, 2, 8);
@@ -5330,7 +5330,7 @@
 }
 
 template <class S, class SV>
-void test50()
+TEST_CONSTEXPR_CXX20 void test50()
 {
     test(S("abcdefghijklmnopqrst"), 10, 11, SV("abcdefghij"), 5, 5, 5);
     test(S("abcdefghijklmnopqrst"), 10, 11, SV("abcdefghij"), 5, 6, 5);
@@ -5435,7 +5435,7 @@
 }
 
 template <class S, class SV>
-void test51()
+TEST_CONSTEXPR_CXX20 void test51()
 {
     test(S("abcdefghijklmnopqrst"), 19, 0, SV("abcdefghijklmnopqrst"), 19, 0, 0);
     test(S("abcdefghijklmnopqrst"), 19, 0, SV("abcdefghijklmnopqrst"), 19, 1, -1);
@@ -5540,7 +5540,7 @@
 }
 
 template <class S, class SV>
-void test52()
+TEST_CONSTEXPR_CXX20 void test52()
 {
     test(S("abcdefghijklmnopqrst"), 19, 2, SV("abcde"), 4, 0, 1);
     test(S("abcdefghijklmnopqrst"), 19, 2, SV("abcde"), 4, 1, 15);
@@ -5645,7 +5645,7 @@
 }
 
 template <class S, class SV>
-void test53()
+TEST_CONSTEXPR_CXX20 void test53()
 {
     test(S("abcdefghijklmnopqrst"), 20, 0, SV("abcdefghij"), 9, 2, -1);
     test(S("abcdefghijklmnopqrst"), 20, 0, SV("abcdefghij"), 10, 0, 0);
@@ -5750,7 +5750,7 @@
 }
 
 template <class S, class SV>
-void test54()
+TEST_CONSTEXPR_CXX20 void test54()
 {
     test(S("abcdefghijklmnopqrst"), 20, 1, SV("abcdefghijklmnopqrst"), 20, 1, 0);
     test(S("abcdefghijklmnopqrst"), 20, 1, SV("abcdefghijklmnopqrst"), 21, 0, 0);
@@ -5831,7 +5831,7 @@
 }
 
 template <class S, class SV>
-void test55()
+TEST_CONSTEXPR_CXX20 void test55()
 {
     test_npos(S(""), 0, 0, SV(""), 0, 0);
     test_npos(S(""), 0, 0, SV("abcde"), 0, -5);
@@ -5840,72 +5840,8 @@
     test_npos(S("abcde"), 0, 0, SV("abcdefghij"), 5, -5);
 }
 
-int main(int, char**)
-{
-    {
-    typedef std::string S;
-    typedef std::string_view SV;
-    test0<S, SV>();
-    test1<S, SV>();
-    test2<S, SV>();
-    test3<S, SV>();
-    test4<S, SV>();
-    test5<S, SV>();
-    test6<S, SV>();
-    test7<S, SV>();
-    test8<S, SV>();
-    test9<S, SV>();
-    test10<S, SV>();
-    test11<S, SV>();
-    test12<S, SV>();
-    test13<S, SV>();
-    test14<S, SV>();
-    test15<S, SV>();
-    test16<S, SV>();
-    test17<S, SV>();
-    test18<S, SV>();
-    test19<S, SV>();
-    test20<S, SV>();
-    test21<S, SV>();
-    test22<S, SV>();
-    test23<S, SV>();
-    test24<S, SV>();
-    test25<S, SV>();
-    test26<S, SV>();
-    test27<S, SV>();
-    test28<S, SV>();
-    test29<S, SV>();
-    test30<S, SV>();
-    test31<S, SV>();
-    test32<S, SV>();
-    test33<S, SV>();
-    test34<S, SV>();
-    test35<S, SV>();
-    test36<S, SV>();
-    test37<S, SV>();
-    test38<S, SV>();
-    test39<S, SV>();
-    test40<S, SV>();
-    test41<S, SV>();
-    test42<S, SV>();
-    test43<S, SV>();
-    test44<S, SV>();
-    test45<S, SV>();
-    test46<S, SV>();
-    test47<S, SV>();
-    test48<S, SV>();
-    test49<S, SV>();
-    test50<S, SV>();
-    test51<S, SV>();
-    test52<S, SV>();
-    test53<S, SV>();
-    test54<S, SV>();
-    test55<S, SV>();
-    }
-#if TEST_STD_VER >= 11
-    {
-    typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
-    typedef std::basic_string_view<char, std::char_traits<char>> SV;
+template<class S, class SV>
+TEST_CONSTEXPR_CXX20 bool test_0() {
     test0<S, SV>();
     test1<S, SV>();
     test2<S, SV>();
@@ -5919,6 +5855,12 @@
     test10<S, SV>();
     test11<S, SV>();
     test12<S, SV>();
+
+    return true;
+}
+
+template<class S, class SV>
+TEST_CONSTEXPR_CXX20 bool test_1() {
     test13<S, SV>();
     test14<S, SV>();
     test15<S, SV>();
@@ -5933,6 +5875,12 @@
     test24<S, SV>();
     test25<S, SV>();
     test26<S, SV>();
+
+    return true;
+}
+
+template<class S, class SV>
+TEST_CONSTEXPR_CXX20 bool test_2() {
     test27<S, SV>();
     test28<S, SV>();
     test29<S, SV>();
@@ -5947,6 +5895,12 @@
     test38<S, SV>();
     test39<S, SV>();
     test40<S, SV>();
+
+    return true;
+}
+
+template<class S, class SV>
+TEST_CONSTEXPR_CXX20 bool test_3() {
     test41<S, SV>();
     test42<S, SV>();
     test43<S, SV>();
@@ -5962,8 +5916,11 @@
     test53<S, SV>();
     test54<S, SV>();
     test55<S, SV>();
-    }
-#endif
+
+    return true;
+}
+
+TEST_CONSTEXPR_CXX20 bool test_4() {
     {
     typedef std::string S;
     typedef std::string_view SV;
@@ -5989,6 +5946,52 @@
 //  calls compare(size, size, string(arr), 0, npos)
     assert(s.compare(0, 4, arr, 0, std::string::npos) == 0);
     }
+    
+  return true;
+}
+
+int main() {
+  {
+    typedef std::string S;
+    typedef std::string_view SV;
+    test_0<S, SV>();
+    test_1<S, SV>();
+    test_2<S, SV>();
+    test_3<S, SV>();
+    test_4();
+  }
+#if TEST_STD_VER >= 11
+  {
+    typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
+    typedef std::basic_string_view<char, std::char_traits<char>> SV;
+    test_0<S, SV>();
+    test_1<S, SV>();
+    test_2<S, SV>();
+    test_3<S, SV>();
+    test_4();
+  }
+#endif
+
+#if TEST_STD_VER > 17
+  {
+    typedef std::string S;
+    typedef std::string_view SV;
+    static_assert(test_0<S, SV>());
+    static_assert(test_1<S, SV>());
+    static_assert(test_2<S, SV>());
+    static_assert(test_3<S, SV>());
+    static_assert(test_4());
+  }
+  {
+    typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
+    typedef std::basic_string_view<char, std::char_traits<char>> SV;
+    static_assert(test_0<S, SV>());
+    static_assert(test_1<S, SV>());
+    static_assert(test_2<S, SV>());
+    static_assert(test_3<S, SV>());
+    static_assert(test_4());
+  }
+#endif
 
   return 0;
-}
+}
\ No newline at end of file
diff --git a/libcxx/test/std/strings/basic.string/string.ops/string_compare/size_size_pointer.pass.cpp b/libcxx/test/std/strings/basic.string/string.ops/string_compare/size_size_pointer.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.ops/string_compare/size_size_pointer.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.ops/string_compare/size_size_pointer.pass.cpp
@@ -18,7 +18,7 @@
 
 #include "test_macros.h"
 
-int sign(int x)
+TEST_CONSTEXPR_CXX20 int sign(int x)
 {
     if (x == 0)
         return 0;
@@ -28,14 +28,14 @@
 }
 
 template <class S>
-void
+TEST_CONSTEXPR_CXX20 void
 test(const S& s, typename S::size_type pos1, typename S::size_type n1,
      const typename S::value_type* str, int x)
 {
     if (pos1 <= s.size())
         assert(sign(s.compare(pos1, n1, str)) == sign(x));
 #ifndef TEST_HAS_NO_EXCEPTIONS
-    else
+    else if (!TEST_IS_CONSTANT_EVALUATED)
     {
         try
         {
@@ -51,7 +51,7 @@
 }
 
 template <class S>
-void test0()
+TEST_CONSTEXPR_CXX20 void test0()
 {
     test(S(""), 0, 0, "", 0);
     test(S(""), 0, 0, "abcde", -5);
@@ -156,7 +156,7 @@
 }
 
 template <class S>
-void test1()
+TEST_CONSTEXPR_CXX20 void test1()
 {
     test(S("abcde"), 6, 0, "", 0);
     test(S("abcde"), 6, 0, "abcde", 0);
@@ -261,7 +261,7 @@
 }
 
 template <class S>
-void test2()
+TEST_CONSTEXPR_CXX20 void test2()
 {
     test(S("abcdefghijklmnopqrst"), 0, 0, "", 0);
     test(S("abcdefghijklmnopqrst"), 0, 0, "abcde", -5);
@@ -361,8 +361,7 @@
     test(S("abcdefghijklmnopqrst"), 21, 0, "abcdefghijklmnopqrst", 0);
 }
 
-int main(int, char**)
-{
+TEST_CONSTEXPR_CXX20 bool test() {
     {
     typedef std::string S;
     test0<S>();
@@ -377,6 +376,15 @@
     test2<S>();
     }
 #endif
+    
+  return true;
+}
+
+int main() {
+  test();
+#if TEST_STD_VER > 17
+  static_assert(test());
+#endif
 
   return 0;
 }
diff --git a/libcxx/test/std/strings/basic.string/string.ops/string_compare/size_size_pointer_size.pass.cpp b/libcxx/test/std/strings/basic.string/string.ops/string_compare/size_size_pointer_size.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.ops/string_compare/size_size_pointer_size.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.ops/string_compare/size_size_pointer_size.pass.cpp
@@ -18,7 +18,7 @@
 
 #include "test_macros.h"
 
-int sign(int x)
+TEST_CONSTEXPR_CXX20 int sign(int x)
 {
     if (x == 0)
         return 0;
@@ -28,14 +28,14 @@
 }
 
 template <class S>
-void
+TEST_CONSTEXPR_CXX20 void
 test(const S& s, typename S::size_type pos, typename S::size_type n1,
      const typename S::value_type* str, typename S::size_type n2, int x)
 {
     if (pos <= s.size())
         assert(sign(s.compare(pos, n1, str, n2)) == sign(x));
 #ifndef TEST_HAS_NO_EXCEPTIONS
-    else
+    else if (!TEST_IS_CONSTANT_EVALUATED)
     {
         try
         {
@@ -51,7 +51,7 @@
 }
 
 template <class S>
-void test0()
+TEST_CONSTEXPR_CXX20 void test0()
 {
     test(S(""), 0, 0, "", 0, 0);
     test(S(""), 0, 0, "abcde", 0, 0);
@@ -156,7 +156,7 @@
 }
 
 template <class S>
-void test1()
+TEST_CONSTEXPR_CXX20 void test1()
 {
     test(S("abcde"), 0, 4, "abcde", 4, 0);
     test(S("abcde"), 0, 4, "abcde", 5, -1);
@@ -261,7 +261,7 @@
 }
 
 template <class S>
-void test2()
+TEST_CONSTEXPR_CXX20 void test2()
 {
     test(S("abcde"), 1, 3, "abcdefghij", 5, 1);
     test(S("abcde"), 1, 3, "abcdefghij", 9, 1);
@@ -366,7 +366,7 @@
 }
 
 template <class S>
-void test3()
+TEST_CONSTEXPR_CXX20 void test3()
 {
     test(S("abcde"), 2, 3, "abcdefghijklmnopqrst", 1, 2);
     test(S("abcde"), 2, 3, "abcdefghijklmnopqrst", 10, 2);
@@ -471,7 +471,7 @@
 }
 
 template <class S>
-void test4()
+TEST_CONSTEXPR_CXX20 void test4()
 {
     test(S("abcde"), 6, 0, "", 0, 0);
     test(S("abcde"), 6, 0, "abcde", 0, 0);
@@ -576,7 +576,7 @@
 }
 
 template <class S>
-void test5()
+TEST_CONSTEXPR_CXX20 void test5()
 {
     test(S("abcdefghij"), 0, 11, "abcde", 4, 6);
     test(S("abcdefghij"), 0, 11, "abcde", 5, 5);
@@ -681,7 +681,7 @@
 }
 
 template <class S>
-void test6()
+TEST_CONSTEXPR_CXX20 void test6()
 {
     test(S("abcdefghij"), 1, 10, "abcdefghij", 5, 1);
     test(S("abcdefghij"), 1, 10, "abcdefghij", 9, 1);
@@ -786,7 +786,7 @@
 }
 
 template <class S>
-void test7()
+TEST_CONSTEXPR_CXX20 void test7()
 {
     test(S("abcdefghij"), 5, 6, "abcdefghijklmnopqrst", 1, 5);
     test(S("abcdefghij"), 5, 6, "abcdefghijklmnopqrst", 10, 5);
@@ -891,7 +891,7 @@
 }
 
 template <class S>
-void test8()
+TEST_CONSTEXPR_CXX20 void test8()
 {
     test(S("abcdefghijklmnopqrst"), 0, 0, "", 0, 0);
     test(S("abcdefghijklmnopqrst"), 0, 0, "abcde", 0, 0);
@@ -996,7 +996,7 @@
 }
 
 template <class S>
-void test9()
+TEST_CONSTEXPR_CXX20 void test9()
 {
     test(S("abcdefghijklmnopqrst"), 1, 0, "abcde", 4, -4);
     test(S("abcdefghijklmnopqrst"), 1, 0, "abcde", 5, -5);
@@ -1101,7 +1101,7 @@
 }
 
 template <class S>
-void test10()
+TEST_CONSTEXPR_CXX20 void test10()
 {
     test(S("abcdefghijklmnopqrst"), 10, 0, "abcdefghij", 5, -5);
     test(S("abcdefghijklmnopqrst"), 10, 0, "abcdefghij", 9, -9);
@@ -1206,7 +1206,7 @@
 }
 
 template <class S>
-void test11()
+TEST_CONSTEXPR_CXX20 void test11()
 {
     test(S("abcdefghijklmnopqrst"), 19, 0, "abcdefghijklmnopqrst", 1, -1);
     test(S("abcdefghijklmnopqrst"), 19, 0, "abcdefghijklmnopqrst", 10, -10);
@@ -1294,8 +1294,7 @@
     test(S("abcdefghijklmnopqrst"), 21, 0, "abcdefghijklmnopqrst", 20, 0);
 }
 
-int main(int, char**)
-{
+TEST_CONSTEXPR_CXX20 bool test() {
     {
     typedef std::string S;
     test0<S>();
@@ -1328,6 +1327,15 @@
     test11<S>();
     }
 #endif
+    
+  return true;
+}
+
+int main() {
+  test();
+#if TEST_STD_VER > 17
+  static_assert(test());
+#endif
 
   return 0;
 }
diff --git a/libcxx/test/std/strings/basic.string/string.ops/string_compare/size_size_string.pass.cpp b/libcxx/test/std/strings/basic.string/string.ops/string_compare/size_size_string.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.ops/string_compare/size_size_string.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.ops/string_compare/size_size_string.pass.cpp
@@ -17,7 +17,7 @@
 #include "test_macros.h"
 #include "min_allocator.h"
 
-int sign(int x)
+TEST_CONSTEXPR_CXX20 int sign(int x)
 {
     if (x == 0)
         return 0;
@@ -27,14 +27,14 @@
 }
 
 template <class S>
-void
+TEST_CONSTEXPR_CXX20 void
 test(const S& s, typename S::size_type pos1, typename S::size_type n1,
      const S& str, int x)
 {
     if (pos1 <= s.size())
         assert(sign(s.compare(pos1, n1, str)) == sign(x));
 #ifndef TEST_HAS_NO_EXCEPTIONS
-    else
+    else if (!TEST_IS_CONSTANT_EVALUATED)
     {
         try
         {
@@ -50,7 +50,7 @@
 }
 
 template <class S>
-void test0()
+TEST_CONSTEXPR_CXX20 void test0()
 {
     test(S(""), 0, 0, S(""), 0);
     test(S(""), 0, 0, S("abcde"), -5);
@@ -155,7 +155,7 @@
 }
 
 template <class S>
-void test1()
+TEST_CONSTEXPR_CXX20 void test1()
 {
     test(S("abcde"), 6, 0, S(""), 0);
     test(S("abcde"), 6, 0, S("abcde"), 0);
@@ -260,7 +260,7 @@
 }
 
 template <class S>
-void test2()
+TEST_CONSTEXPR_CXX20 void test2()
 {
     test(S("abcdefghijklmnopqrst"), 0, 0, S(""), 0);
     test(S("abcdefghijklmnopqrst"), 0, 0, S("abcde"), -5);
@@ -360,8 +360,7 @@
     test(S("abcdefghijklmnopqrst"), 21, 0, S("abcdefghijklmnopqrst"), 0);
 }
 
-int main(int, char**)
-{
+TEST_CONSTEXPR_CXX20 bool test() {
     {
     typedef std::string S;
     test0<S>();
@@ -383,6 +382,15 @@
     assert(s.compare(0, 1, {"abc", 1}) < 0);
     }
 #endif
+    
+  return true;
+}
+
+int main() {
+  test();
+#if TEST_STD_VER > 17
+  static_assert(test());
+#endif
 
   return 0;
 }
diff --git a/libcxx/test/std/strings/basic.string/string.ops/string_compare/size_size_string_size_size.pass.cpp b/libcxx/test/std/strings/basic.string/string.ops/string_compare/size_size_string_size_size.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.ops/string_compare/size_size_string_size_size.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.ops/string_compare/size_size_string_size_size.pass.cpp
@@ -20,7 +20,7 @@
 
 #include "test_macros.h"
 
-int sign(int x)
+TEST_CONSTEXPR_CXX20 int sign(int x)
 {
     if (x == 0)
         return 0;
@@ -30,14 +30,14 @@
 }
 
 template <class S>
-void
+TEST_CONSTEXPR_CXX20 void
 test(const S& s,   typename S::size_type pos1, typename S::size_type n1,
      const S& str, typename S::size_type pos2, typename S::size_type n2, int x)
 {
     if (pos1 <= s.size() && pos2 <= str.size())
         assert(sign(s.compare(pos1, n1, str, pos2, n2)) == sign(x));
 #ifndef TEST_HAS_NO_EXCEPTIONS
-    else
+    else if (!TEST_IS_CONSTANT_EVALUATED)
     {
         try
         {
@@ -53,7 +53,7 @@
 }
 
 template <class S>
-void
+TEST_CONSTEXPR_CXX20 void
 test_npos(const S& s,   typename S::size_type pos1, typename S::size_type n1,
           const S& str, typename S::size_type pos2, int x)
 {
@@ -76,7 +76,7 @@
 }
 
 template <class S>
-void test0()
+TEST_CONSTEXPR_CXX20 void test0()
 {
     test(S(""), 0, 0, S(""), 0, 0, 0);
     test(S(""), 0, 0, S(""), 0, 1, 0);
@@ -181,7 +181,7 @@
 }
 
 template <class S>
-void test1()
+TEST_CONSTEXPR_CXX20 void test1()
 {
     test(S(""), 0, 1, S("abcdefghij"), 0, 0, 0);
     test(S(""), 0, 1, S("abcdefghij"), 0, 1, -1);
@@ -286,7 +286,7 @@
 }
 
 template <class S>
-void test2()
+TEST_CONSTEXPR_CXX20 void test2()
 {
     test(S(""), 1, 0, S("abcdefghijklmnopqrst"), 0, 10, 0);
     test(S(""), 1, 0, S("abcdefghijklmnopqrst"), 0, 19, 0);
@@ -391,7 +391,7 @@
 }
 
 template <class S>
-void test3()
+TEST_CONSTEXPR_CXX20 void test3()
 {
     test(S("abcde"), 0, 1, S("abcde"), 0, 1, 0);
     test(S("abcde"), 0, 1, S("abcde"), 0, 2, -1);
@@ -496,7 +496,7 @@
 }
 
 template <class S>
-void test4()
+TEST_CONSTEXPR_CXX20 void test4()
 {
     test(S("abcde"), 0, 2, S("abcdefghij"), 0, 10, -8);
     test(S("abcde"), 0, 2, S("abcdefghij"), 0, 11, -8);
@@ -601,7 +601,7 @@
 }
 
 template <class S>
-void test5()
+TEST_CONSTEXPR_CXX20 void test5()
 {
     test(S("abcde"), 0, 4, S("abcdefghijklmnopqrst"), 1, 0, 4);
     test(S("abcde"), 0, 4, S("abcdefghijklmnopqrst"), 1, 1, -1);
@@ -706,7 +706,7 @@
 }
 
 template <class S>
-void test6()
+TEST_CONSTEXPR_CXX20 void test6()
 {
     test(S("abcde"), 0, 6, S("abcde"), 0, 6, 0);
     test(S("abcde"), 0, 6, S("abcde"), 1, 0, 5);
@@ -811,7 +811,7 @@
 }
 
 template <class S>
-void test7()
+TEST_CONSTEXPR_CXX20 void test7()
 {
     test(S("abcde"), 1, 0, S("abcdefghij"), 1, 4, -4);
     test(S("abcde"), 1, 0, S("abcdefghij"), 1, 8, -8);
@@ -916,7 +916,7 @@
 }
 
 template <class S>
-void test8()
+TEST_CONSTEXPR_CXX20 void test8()
 {
     test(S("abcde"), 1, 1, S("abcdefghijklmnopqrst"), 1, 19, -18);
     test(S("abcde"), 1, 1, S("abcdefghijklmnopqrst"), 1, 20, -18);
@@ -1021,7 +1021,7 @@
 }
 
 template <class S>
-void test9()
+TEST_CONSTEXPR_CXX20 void test9()
 {
     test(S("abcde"), 1, 3, S("abcde"), 1, 3, 0);
     test(S("abcde"), 1, 3, S("abcde"), 1, 4, -1);
@@ -1126,7 +1126,7 @@
 }
 
 template <class S>
-void test10()
+TEST_CONSTEXPR_CXX20 void test10()
 {
     test(S("abcde"), 1, 4, S("abcdefghij"), 5, 0, 4);
     test(S("abcde"), 1, 4, S("abcdefghij"), 5, 1, -4);
@@ -1231,7 +1231,7 @@
 }
 
 template <class S>
-void test11()
+TEST_CONSTEXPR_CXX20 void test11()
 {
     test(S("abcde"), 1, 5, S("abcdefghijklmnopqrst"), 10, 5, -9);
     test(S("abcde"), 1, 5, S("abcdefghijklmnopqrst"), 10, 9, -9);
@@ -1336,7 +1336,7 @@
 }
 
 template <class S>
-void test12()
+TEST_CONSTEXPR_CXX20 void test12()
 {
     test(S("abcde"), 2, 1, S("abcde"), 2, 1, 0);
     test(S("abcde"), 2, 1, S("abcde"), 2, 2, -1);
@@ -1441,7 +1441,7 @@
 }
 
 template <class S>
-void test13()
+TEST_CONSTEXPR_CXX20 void test13()
 {
     test(S("abcde"), 2, 2, S("abcdefghij"), 5, 5, -3);
     test(S("abcde"), 2, 2, S("abcdefghij"), 5, 6, -3);
@@ -1546,7 +1546,7 @@
 }
 
 template <class S>
-void test14()
+TEST_CONSTEXPR_CXX20 void test14()
 {
     test(S("abcde"), 2, 3, S("abcdefghijklmnopqrst"), 19, 0, 3);
     test(S("abcde"), 2, 3, S("abcdefghijklmnopqrst"), 19, 1, -17);
@@ -1651,7 +1651,7 @@
 }
 
 template <class S>
-void test15()
+TEST_CONSTEXPR_CXX20 void test15()
 {
     test(S("abcde"), 4, 0, S("abcde"), 4, 0, 0);
     test(S("abcde"), 4, 0, S("abcde"), 4, 1, -1);
@@ -1756,7 +1756,7 @@
 }
 
 template <class S>
-void test16()
+TEST_CONSTEXPR_CXX20 void test16()
 {
     test(S("abcde"), 4, 1, S("abcdefghij"), 9, 2, -5);
     test(S("abcde"), 4, 1, S("abcdefghij"), 10, 0, 1);
@@ -1861,7 +1861,7 @@
 }
 
 template <class S>
-void test17()
+TEST_CONSTEXPR_CXX20 void test17()
 {
     test(S("abcde"), 4, 2, S("abcdefghijklmnopqrst"), 20, 1, 1);
     test(S("abcde"), 4, 2, S("abcdefghijklmnopqrst"), 21, 0, 0);
@@ -1966,7 +1966,7 @@
 }
 
 template <class S>
-void test18()
+TEST_CONSTEXPR_CXX20 void test18()
 {
     test(S("abcde"), 5, 1, S("abcde"), 5, 1, 0);
     test(S("abcde"), 5, 1, S("abcde"), 6, 0, 0);
@@ -2071,7 +2071,7 @@
 }
 
 template <class S>
-void test19()
+TEST_CONSTEXPR_CXX20 void test19()
 {
     test(S("abcde"), 6, 0, S("abcdefghijklmnopqrst"), 0, 0, 0);
     test(S("abcde"), 6, 0, S("abcdefghijklmnopqrst"), 0, 1, 0);
@@ -2176,7 +2176,7 @@
 }
 
 template <class S>
-void test20()
+TEST_CONSTEXPR_CXX20 void test20()
 {
     test(S("abcdefghij"), 0, 1, S(""), 1, 0, 0);
     test(S("abcdefghij"), 0, 1, S("abcde"), 0, 0, 1);
@@ -2281,7 +2281,7 @@
 }
 
 template <class S>
-void test21()
+TEST_CONSTEXPR_CXX20 void test21()
 {
     test(S("abcdefghij"), 0, 5, S("abcdefghij"), 0, 5, 0);
     test(S("abcdefghij"), 0, 5, S("abcdefghij"), 0, 9, -4);
@@ -2386,7 +2386,7 @@
 }
 
 template <class S>
-void test22()
+TEST_CONSTEXPR_CXX20 void test22()
 {
     test(S("abcdefghij"), 0, 9, S("abcdefghijklmnopqrst"), 0, 20, -11);
     test(S("abcdefghij"), 0, 9, S("abcdefghijklmnopqrst"), 0, 21, -11);
@@ -2491,7 +2491,7 @@
 }
 
 template <class S>
-void test23()
+TEST_CONSTEXPR_CXX20 void test23()
 {
     test(S("abcdefghij"), 0, 11, S("abcde"), 0, 4, 6);
     test(S("abcdefghij"), 0, 11, S("abcde"), 0, 5, 5);
@@ -2596,7 +2596,7 @@
 }
 
 template <class S>
-void test24()
+TEST_CONSTEXPR_CXX20 void test24()
 {
     test(S("abcdefghij"), 1, 0, S("abcdefghij"), 1, 0, 0);
     test(S("abcdefghij"), 1, 0, S("abcdefghij"), 1, 1, -1);
@@ -2701,7 +2701,7 @@
 }
 
 template <class S>
-void test25()
+TEST_CONSTEXPR_CXX20 void test25()
 {
     test(S("abcdefghij"), 1, 1, S("abcdefghijklmnopqrst"), 1, 9, -8);
     test(S("abcdefghij"), 1, 1, S("abcdefghijklmnopqrst"), 1, 18, -17);
@@ -2806,7 +2806,7 @@
 }
 
 template <class S>
-void test26()
+TEST_CONSTEXPR_CXX20 void test26()
 {
     test(S("abcdefghij"), 1, 8, S("abcde"), 1, 1, 7);
     test(S("abcdefghij"), 1, 8, S("abcde"), 1, 2, 6);
@@ -2911,7 +2911,7 @@
 }
 
 template <class S>
-void test27()
+TEST_CONSTEXPR_CXX20 void test27()
 {
     test(S("abcdefghij"), 1, 9, S("abcdefghij"), 1, 9, 0);
     test(S("abcdefghij"), 1, 9, S("abcdefghij"), 1, 10, 0);
@@ -3016,7 +3016,7 @@
 }
 
 template <class S>
-void test28()
+TEST_CONSTEXPR_CXX20 void test28()
 {
     test(S("abcdefghij"), 1, 10, S("abcdefghijklmnopqrst"), 10, 0, 9);
     test(S("abcdefghij"), 1, 10, S("abcdefghijklmnopqrst"), 10, 1, -9);
@@ -3121,7 +3121,7 @@
 }
 
 template <class S>
-void test29()
+TEST_CONSTEXPR_CXX20 void test29()
 {
     test(S("abcdefghij"), 5, 1, S("abcde"), 1, 5, 4);
     test(S("abcdefghij"), 5, 1, S("abcde"), 2, 0, 1);
@@ -3226,7 +3226,7 @@
 }
 
 template <class S>
-void test30()
+TEST_CONSTEXPR_CXX20 void test30()
 {
     test(S("abcdefghij"), 5, 2, S("abcdefghij"), 5, 2, 0);
     test(S("abcdefghij"), 5, 2, S("abcdefghij"), 5, 4, -2);
@@ -3331,7 +3331,7 @@
 }
 
 template <class S>
-void test31()
+TEST_CONSTEXPR_CXX20 void test31()
 {
     test(S("abcdefghij"), 5, 4, S("abcdefghijklmnopqrst"), 10, 10, -5);
     test(S("abcdefghij"), 5, 4, S("abcdefghijklmnopqrst"), 10, 11, -5);
@@ -3436,7 +3436,7 @@
 }
 
 template <class S>
-void test32()
+TEST_CONSTEXPR_CXX20 void test32()
 {
     test(S("abcdefghij"), 5, 6, S("abcde"), 2, 3, 3);
     test(S("abcdefghij"), 5, 6, S("abcde"), 2, 4, 3);
@@ -3541,7 +3541,7 @@
 }
 
 template <class S>
-void test33()
+TEST_CONSTEXPR_CXX20 void test33()
 {
     test(S("abcdefghij"), 9, 0, S("abcdefghij"), 9, 0, 0);
     test(S("abcdefghij"), 9, 0, S("abcdefghij"), 9, 1, -1);
@@ -3646,7 +3646,7 @@
 }
 
 template <class S>
-void test34()
+TEST_CONSTEXPR_CXX20 void test34()
 {
     test(S("abcdefghij"), 9, 1, S("abcdefghijklmnopqrst"), 19, 2, -10);
     test(S("abcdefghij"), 9, 1, S("abcdefghijklmnopqrst"), 20, 0, 1);
@@ -3751,7 +3751,7 @@
 }
 
 template <class S>
-void test35()
+TEST_CONSTEXPR_CXX20 void test35()
 {
     test(S("abcdefghij"), 10, 0, S("abcde"), 4, 2, -1);
     test(S("abcdefghij"), 10, 0, S("abcde"), 5, 0, 0);
@@ -3856,7 +3856,7 @@
 }
 
 template <class S>
-void test36()
+TEST_CONSTEXPR_CXX20 void test36()
 {
     test(S("abcdefghij"), 10, 1, S("abcdefghij"), 10, 1, 0);
     test(S("abcdefghij"), 10, 1, S("abcdefghij"), 11, 0, 0);
@@ -3961,7 +3961,7 @@
 }
 
 template <class S>
-void test37()
+TEST_CONSTEXPR_CXX20 void test37()
 {
     test(S("abcdefghijklmnopqrst"), 0, 0, S(""), 0, 0, 0);
     test(S("abcdefghijklmnopqrst"), 0, 0, S(""), 0, 1, 0);
@@ -4066,7 +4066,7 @@
 }
 
 template <class S>
-void test38()
+TEST_CONSTEXPR_CXX20 void test38()
 {
     test(S("abcdefghijklmnopqrst"), 0, 1, S("abcdefghij"), 0, 0, 1);
     test(S("abcdefghijklmnopqrst"), 0, 1, S("abcdefghij"), 0, 1, 0);
@@ -4171,7 +4171,7 @@
 }
 
 template <class S>
-void test39()
+TEST_CONSTEXPR_CXX20 void test39()
 {
     test(S("abcdefghijklmnopqrst"), 0, 10, S("abcdefghijklmnopqrst"), 0, 10, 0);
     test(S("abcdefghijklmnopqrst"), 0, 10, S("abcdefghijklmnopqrst"), 0, 19, -9);
@@ -4276,7 +4276,7 @@
 }
 
 template <class S>
-void test40()
+TEST_CONSTEXPR_CXX20 void test40()
 {
     test(S("abcdefghijklmnopqrst"), 0, 20, S("abcde"), 0, 1, 19);
     test(S("abcdefghijklmnopqrst"), 0, 20, S("abcde"), 0, 2, 18);
@@ -4381,7 +4381,7 @@
 }
 
 template <class S>
-void test41()
+TEST_CONSTEXPR_CXX20 void test41()
 {
     test(S("abcdefghijklmnopqrst"), 0, 21, S("abcdefghij"), 0, 10, 10);
     test(S("abcdefghijklmnopqrst"), 0, 21, S("abcdefghij"), 0, 11, 10);
@@ -4486,7 +4486,7 @@
 }
 
 template <class S>
-void test42()
+TEST_CONSTEXPR_CXX20 void test42()
 {
     test(S("abcdefghijklmnopqrst"), 1, 0, S("abcdefghijklmnopqrst"), 1, 0, 0);
     test(S("abcdefghijklmnopqrst"), 1, 0, S("abcdefghijklmnopqrst"), 1, 1, -1);
@@ -4591,7 +4591,7 @@
 }
 
 template <class S>
-void test43()
+TEST_CONSTEXPR_CXX20 void test43()
 {
     test(S("abcdefghijklmnopqrst"), 1, 9, S("abcde"), 0, 6, 1);
     test(S("abcdefghijklmnopqrst"), 1, 9, S("abcde"), 1, 0, 9);
@@ -4696,7 +4696,7 @@
 }
 
 template <class S>
-void test44()
+TEST_CONSTEXPR_CXX20 void test44()
 {
     test(S("abcdefghijklmnopqrst"), 1, 18, S("abcdefghij"), 1, 4, 14);
     test(S("abcdefghijklmnopqrst"), 1, 18, S("abcdefghij"), 1, 8, 10);
@@ -4801,7 +4801,7 @@
 }
 
 template <class S>
-void test45()
+TEST_CONSTEXPR_CXX20 void test45()
 {
     test(S("abcdefghijklmnopqrst"), 1, 19, S("abcdefghijklmnopqrst"), 1, 19, 0);
     test(S("abcdefghijklmnopqrst"), 1, 19, S("abcdefghijklmnopqrst"), 1, 20, 0);
@@ -4906,7 +4906,7 @@
 }
 
 template <class S>
-void test46()
+TEST_CONSTEXPR_CXX20 void test46()
 {
     test(S("abcdefghijklmnopqrst"), 10, 0, S("abcde"), 1, 3, -3);
     test(S("abcdefghijklmnopqrst"), 10, 0, S("abcde"), 1, 4, -4);
@@ -5011,7 +5011,7 @@
 }
 
 template <class S>
-void test47()
+TEST_CONSTEXPR_CXX20 void test47()
 {
     test(S("abcdefghijklmnopqrst"), 10, 1, S("abcdefghij"), 5, 0, 1);
     test(S("abcdefghijklmnopqrst"), 10, 1, S("abcdefghij"), 5, 1, 5);
@@ -5116,7 +5116,7 @@
 }
 
 template <class S>
-void test48()
+TEST_CONSTEXPR_CXX20 void test48()
 {
     test(S("abcdefghijklmnopqrst"), 10, 5, S("abcdefghijklmnopqrst"), 10, 5, 0);
     test(S("abcdefghijklmnopqrst"), 10, 5, S("abcdefghijklmnopqrst"), 10, 9, -4);
@@ -5221,7 +5221,7 @@
 }
 
 template <class S>
-void test49()
+TEST_CONSTEXPR_CXX20 void test49()
 {
     test(S("abcdefghijklmnopqrst"), 10, 10, S("abcde"), 2, 1, 8);
     test(S("abcdefghijklmnopqrst"), 10, 10, S("abcde"), 2, 2, 8);
@@ -5326,7 +5326,7 @@
 }
 
 template <class S>
-void test50()
+TEST_CONSTEXPR_CXX20 void test50()
 {
     test(S("abcdefghijklmnopqrst"), 10, 11, S("abcdefghij"), 5, 5, 5);
     test(S("abcdefghijklmnopqrst"), 10, 11, S("abcdefghij"), 5, 6, 5);
@@ -5431,7 +5431,7 @@
 }
 
 template <class S>
-void test51()
+TEST_CONSTEXPR_CXX20 void test51()
 {
     test(S("abcdefghijklmnopqrst"), 19, 0, S("abcdefghijklmnopqrst"), 19, 0, 0);
     test(S("abcdefghijklmnopqrst"), 19, 0, S("abcdefghijklmnopqrst"), 19, 1, -1);
@@ -5536,7 +5536,7 @@
 }
 
 template <class S>
-void test52()
+TEST_CONSTEXPR_CXX20 void test52()
 {
     test(S("abcdefghijklmnopqrst"), 19, 2, S("abcde"), 4, 0, 1);
     test(S("abcdefghijklmnopqrst"), 19, 2, S("abcde"), 4, 1, 15);
@@ -5641,7 +5641,7 @@
 }
 
 template <class S>
-void test53()
+TEST_CONSTEXPR_CXX20 void test53()
 {
     test(S("abcdefghijklmnopqrst"), 20, 0, S("abcdefghij"), 9, 2, -1);
     test(S("abcdefghijklmnopqrst"), 20, 0, S("abcdefghij"), 10, 0, 0);
@@ -5746,7 +5746,7 @@
 }
 
 template <class S>
-void test54()
+TEST_CONSTEXPR_CXX20 void test54()
 {
     test(S("abcdefghijklmnopqrst"), 20, 1, S("abcdefghijklmnopqrst"), 20, 1, 0);
     test(S("abcdefghijklmnopqrst"), 20, 1, S("abcdefghijklmnopqrst"), 21, 0, 0);
@@ -5827,7 +5827,7 @@
 }
 
 template<class S>
-void test55()
+TEST_CONSTEXPR_CXX20 void test55()
 {
     test_npos(S(""), 0, 0, S(""), 0, 0);
     test_npos(S(""), 0, 0, S("abcde"), 0, -5);
@@ -5836,10 +5836,8 @@
     test_npos(S("abcde"), 0, 0, S("abcdefghij"), 5, -5);
 }
 
-int main(int, char**)
-{
-    {
-    typedef std::string S;
+template<class S>
+TEST_CONSTEXPR_CXX20 bool test_0() {
     test0<S>();
     test1<S>();
     test2<S>();
@@ -5853,6 +5851,12 @@
     test10<S>();
     test11<S>();
     test12<S>();
+
+    return true;
+}
+
+template<class S>
+TEST_CONSTEXPR_CXX20 bool test_1() {
     test13<S>();
     test14<S>();
     test15<S>();
@@ -5865,68 +5869,14 @@
     test22<S>();
     test23<S>();
     test24<S>();
-    test25<S>();
-    test26<S>();
-    test27<S>();
-    test28<S>();
-    test29<S>();
-    test30<S>();
-    test31<S>();
-    test32<S>();
-    test33<S>();
-    test34<S>();
-    test35<S>();
-    test36<S>();
-    test37<S>();
-    test38<S>();
-    test39<S>();
-    test40<S>();
+
+    return true;
+}
+
+template<class S>
+TEST_CONSTEXPR_CXX20 bool test_2() {
     test41<S>();
     test42<S>();
-    test43<S>();
-    test44<S>();
-    test45<S>();
-    test46<S>();
-    test47<S>();
-    test48<S>();
-    test49<S>();
-    test50<S>();
-    test51<S>();
-    test52<S>();
-    test53<S>();
-    test54<S>();
-    test55<S>();
-    }
-#if TEST_STD_VER >= 11
-    {
-    typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
-    test0<S>();
-    test1<S>();
-    test2<S>();
-    test3<S>();
-    test4<S>();
-    test5<S>();
-    test6<S>();
-    test7<S>();
-    test8<S>();
-    test9<S>();
-    test10<S>();
-    test11<S>();
-    test12<S>();
-    test13<S>();
-    test14<S>();
-    test15<S>();
-    test16<S>();
-    test17<S>();
-    test18<S>();
-    test19<S>();
-    test20<S>();
-    test21<S>();
-    test22<S>();
-    test23<S>();
-    test24<S>();
-    test25<S>();
-    test26<S>();
     test27<S>();
     test28<S>();
     test29<S>();
@@ -5937,6 +5887,12 @@
     test34<S>();
     test35<S>();
     test36<S>();
+
+    return true;
+}
+
+template<class S>
+TEST_CONSTEXPR_CXX20 bool test_3() {
     test37<S>();
     test38<S>();
     test39<S>();
@@ -5948,6 +5904,12 @@
     test45<S>();
     test46<S>();
     test47<S>();
+
+    return true;
+}
+
+template<class S>
+TEST_CONSTEXPR_CXX20 bool test_4() {
     test48<S>();
     test49<S>();
     test50<S>();
@@ -5956,7 +5918,47 @@
     test53<S>();
     test54<S>();
     test55<S>();
-    }
+
+    return true;
+}
+
+int main() {
+  {
+    typedef std::string S;
+    test_0<S>();
+    test_1<S>();
+    test_2<S>();
+    test_3<S>();
+    test_4<S>();
+  }
+#if TEST_STD_VER >= 11
+  {
+    typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
+    test_0<S>();
+    test_1<S>();
+    test_2<S>();
+    test_3<S>();
+    test_4<S>();
+  }
+#endif
+
+#if TEST_STD_VER > 17
+  {
+    typedef std::string S;
+    static_assert(test_0<S>());
+    static_assert(test_1<S>());
+    static_assert(test_2<S>());
+    static_assert(test_3<S>());
+    static_assert(test_4<S>());
+  }
+  {
+    typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
+    static_assert(test_0<S>());
+    static_assert(test_1<S>());
+    static_assert(test_2<S>());
+    static_assert(test_3<S>());
+    static_assert(test_4<S>());
+  }
 #endif
 
   return 0;
diff --git a/libcxx/test/std/strings/basic.string/string.ops/string_compare/size_size_string_view.pass.cpp b/libcxx/test/std/strings/basic.string/string.ops/string_compare/size_size_string_view.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.ops/string_compare/size_size_string_view.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.ops/string_compare/size_size_string_view.pass.cpp
@@ -18,7 +18,7 @@
 
 #include "test_macros.h"
 
-int sign(int x)
+TEST_CONSTEXPR_CXX20 int sign(int x)
 {
     if (x == 0)
         return 0;
@@ -28,14 +28,14 @@
 }
 
 template <class S, class SV>
-void
+TEST_CONSTEXPR_CXX20 void
 test(const S& s, typename S::size_type pos1, typename S::size_type n1,
      SV sv, int x)
 {
     if (pos1 <= s.size())
         assert(sign(s.compare(pos1, n1, sv)) == sign(x));
 #ifndef TEST_HAS_NO_EXCEPTIONS
-    else
+    else if (!TEST_IS_CONSTANT_EVALUATED)
     {
         try
         {
@@ -51,7 +51,7 @@
 }
 
 template <class S, class SV>
-void test0()
+TEST_CONSTEXPR_CXX20 void test0()
 {
     test(S(""), 0, 0, SV(""), 0);
     test(S(""), 0, 0, SV("abcde"), -5);
@@ -156,7 +156,7 @@
 }
 
 template <class S, class SV>
-void test1()
+TEST_CONSTEXPR_CXX20 void test1()
 {
     test(S("abcde"), 6, 0, SV(""), 0);
     test(S("abcde"), 6, 0, SV("abcde"), 0);
@@ -261,7 +261,7 @@
 }
 
 template <class S, class SV>
-void test2()
+TEST_CONSTEXPR_CXX20 void test2()
 {
     test(S("abcdefghijklmnopqrst"), 0, 0, SV(""), 0);
     test(S("abcdefghijklmnopqrst"), 0, 0, SV("abcde"), -5);
@@ -361,8 +361,7 @@
     test(S("abcdefghijklmnopqrst"), 21, 0, SV("abcdefghijklmnopqrst"), 0);
 }
 
-int main(int, char**)
-{
+TEST_CONSTEXPR_CXX20 bool test() {
     {
     typedef std::string S;
     typedef std::string_view SV;
@@ -379,6 +378,15 @@
     test2<S, SV>();
     }
 #endif
+    
+  return true;
+}
+
+int main() {
+  test();
+#if TEST_STD_VER > 17
+  static_assert(test());
+#endif
 
   return 0;
 }
diff --git a/libcxx/test/std/strings/basic.string/string.ops/string_compare/string.pass.cpp b/libcxx/test/std/strings/basic.string/string.ops/string_compare/string.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.ops/string_compare/string.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.ops/string_compare/string.pass.cpp
@@ -16,7 +16,7 @@
 #include "test_macros.h"
 #include "min_allocator.h"
 
-int sign(int x)
+TEST_CONSTEXPR_CXX20 int sign(int x)
 {
     if (x == 0)
         return 0;
@@ -26,15 +26,14 @@
 }
 
 template <class S>
-void
+TEST_CONSTEXPR_CXX20 void
 test(const S& s, const S& str, int x)
 {
     LIBCPP_ASSERT_NOEXCEPT(s.compare(str));
     assert(sign(s.compare(str)) == sign(x));
 }
 
-int main(int, char**)
-{
+TEST_CONSTEXPR_CXX20 bool test() {
     {
     typedef std::string S;
     test(S(""), S(""), 0);
@@ -82,6 +81,15 @@
     assert(s.compare({"abc", 1}) < 0);
     }
 #endif
+    
+  return true;
+}
+
+int main() {
+  test();
+#if TEST_STD_VER > 17
+  static_assert(test());
+#endif
 
   return 0;
 }
diff --git a/libcxx/test/std/strings/basic.string/string.ops/string_compare/string_view.pass.cpp b/libcxx/test/std/strings/basic.string/string.ops/string_compare/string_view.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.ops/string_compare/string_view.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.ops/string_compare/string_view.pass.cpp
@@ -16,7 +16,7 @@
 #include "test_macros.h"
 #include "min_allocator.h"
 
-int sign(int x)
+TEST_CONSTEXPR_CXX20 int sign(int x)
 {
     if (x == 0)
         return 0;
@@ -26,15 +26,14 @@
 }
 
 template <class S, class SV>
-void
+TEST_CONSTEXPR_CXX20 void
 test(const S& s, SV sv, int x)
 {
     LIBCPP_ASSERT_NOEXCEPT(s.compare(sv));
     assert(sign(s.compare(sv)) == sign(x));
 }
 
-int main(int, char**)
-{
+TEST_CONSTEXPR_CXX20 bool test() {
     {
     typedef std::string S;
     typedef std::string_view SV;
@@ -77,6 +76,15 @@
     test(S("abcdefghijklmnopqrst"), SV("abcdefghijklmnopqrst"), 0);
     }
 #endif
+    
+  return true;
+}
+
+int main() {
+  test();
+#if TEST_STD_VER > 17
+  static_assert(test());
+#endif
 
   return 0;
 }
diff --git a/libcxx/test/std/strings/basic.string/string.ops/string_find.first.not.of/char_size.pass.cpp b/libcxx/test/std/strings/basic.string/string.ops/string_find.first.not.of/char_size.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.ops/string_find.first.not.of/char_size.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.ops/string_find.first.not.of/char_size.pass.cpp
@@ -17,7 +17,7 @@
 #include "min_allocator.h"
 
 template <class S>
-void
+TEST_CONSTEXPR_CXX20 void
 test(const S& s, typename S::value_type c, typename S::size_type pos,
      typename S::size_type x)
 {
@@ -28,7 +28,7 @@
 }
 
 template <class S>
-void
+TEST_CONSTEXPR_CXX20 void
 test(const S& s, typename S::value_type c, typename S::size_type x)
 {
     LIBCPP_ASSERT_NOEXCEPT(s.find_first_not_of(c));
@@ -37,8 +37,7 @@
         assert(x < s.size());
 }
 
-int main(int, char**)
-{
+TEST_CONSTEXPR_CXX20 bool test() {
     {
     typedef std::string S;
     test(S(""), 'q', 0, S::npos);
@@ -101,6 +100,15 @@
     test(S("laenfsbridchgotmkqpj"), 'q', 0);
     }
 #endif
+    
+  return true;
+}
+
+int main() {
+  test();
+#if TEST_STD_VER > 17
+  static_assert(test());
+#endif
 
   return 0;
 }
diff --git a/libcxx/test/std/strings/basic.string/string.ops/string_find.first.not.of/pointer_size.pass.cpp b/libcxx/test/std/strings/basic.string/string.ops/string_find.first.not.of/pointer_size.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.ops/string_find.first.not.of/pointer_size.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.ops/string_find.first.not.of/pointer_size.pass.cpp
@@ -17,7 +17,7 @@
 #include "min_allocator.h"
 
 template <class S>
-void
+TEST_CONSTEXPR_CXX20 void
 test(const S& s, const typename S::value_type* str, typename S::size_type pos,
      typename S::size_type x)
 {
@@ -28,7 +28,7 @@
 }
 
 template <class S>
-void
+TEST_CONSTEXPR_CXX20 void
 test(const S& s, const typename S::value_type* str, typename S::size_type x)
 {
     assert(s.find_first_not_of(str) == x);
@@ -37,7 +37,7 @@
 }
 
 template <class S>
-void test0()
+TEST_CONSTEXPR_CXX20 void test0()
 {
     test(S(""), "", 0, S::npos);
     test(S(""), "laenf", 0, S::npos);
@@ -122,7 +122,7 @@
 }
 
 template <class S>
-void test1()
+TEST_CONSTEXPR_CXX20 void test1()
 {
     test(S(""), "", S::npos);
     test(S(""), "laenf", S::npos);
@@ -142,8 +142,7 @@
     test(S("pniotcfrhqsmgdkjbael"), "htaobedqikfplcgjsmrn", S::npos);
 }
 
-int main(int, char**)
-{
+TEST_CONSTEXPR_CXX20 bool test() {
     {
     typedef std::string S;
     test0<S>();
@@ -156,6 +155,15 @@
     test1<S>();
     }
 #endif
+    
+  return true;
+}
+
+int main() {
+  test();
+#if TEST_STD_VER > 17
+  static_assert(test());
+#endif
 
   return 0;
 }
diff --git a/libcxx/test/std/strings/basic.string/string.ops/string_find.first.not.of/pointer_size_size.pass.cpp b/libcxx/test/std/strings/basic.string/string.ops/string_find.first.not.of/pointer_size_size.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.ops/string_find.first.not.of/pointer_size_size.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.ops/string_find.first.not.of/pointer_size_size.pass.cpp
@@ -17,7 +17,7 @@
 #include "min_allocator.h"
 
 template <class S>
-void
+TEST_CONSTEXPR_CXX20 void
 test(const S& s, const typename S::value_type* str, typename S::size_type pos,
      typename S::size_type n, typename S::size_type x)
 {
@@ -28,7 +28,7 @@
 }
 
 template <class S>
-void test0()
+TEST_CONSTEXPR_CXX20 void test0()
 {
     test(S(""), "", 0, 0, S::npos);
     test(S(""), "irkhs", 0, 0, S::npos);
@@ -133,7 +133,7 @@
 }
 
 template <class S>
-void test1()
+TEST_CONSTEXPR_CXX20 void test1()
 {
     test(S("gbhqo"), "skqne", 5, 4, S::npos);
     test(S("ktdor"), "kipnf", 5, 5, S::npos);
@@ -238,7 +238,7 @@
 }
 
 template <class S>
-void test2()
+TEST_CONSTEXPR_CXX20 void test2()
 {
     test(S("sdpcilonqj"), "dnjfsagktr", 10, 5, S::npos);
     test(S("gtfbdkqeml"), "nejaktmiqg", 10, 9, S::npos);
@@ -343,7 +343,7 @@
 }
 
 template <class S>
-void test3()
+TEST_CONSTEXPR_CXX20 void test3()
 {
     test(S("pboqganrhedjmltsicfk"), "gbkhdnpoietfcmrslajq", 20, 1, S::npos);
     test(S("klchabsimetjnqgorfpd"), "rtfnmbsglkjaichoqedp", 20, 10, S::npos);
@@ -367,8 +367,7 @@
     test(S("hnbrcplsjfgiktoedmaq"), "qprlsfojamgndekthibc", 21, 20, S::npos);
 }
 
-int main(int, char**)
-{
+TEST_CONSTEXPR_CXX20 bool test() {
     {
     typedef std::string S;
     test0<S>();
@@ -385,6 +384,15 @@
     test3<S>();
     }
 #endif
+    
+  return true;
+}
+
+int main() {
+  test();
+#if TEST_STD_VER > 17
+  static_assert(test());
+#endif
 
   return 0;
 }
diff --git a/libcxx/test/std/strings/basic.string/string.ops/string_find.first.not.of/string_size.pass.cpp b/libcxx/test/std/strings/basic.string/string.ops/string_find.first.not.of/string_size.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.ops/string_find.first.not.of/string_size.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.ops/string_find.first.not.of/string_size.pass.cpp
@@ -17,7 +17,7 @@
 #include "min_allocator.h"
 
 template <class S>
-void
+TEST_CONSTEXPR_CXX20 void
 test(const S& s, const S& str, typename S::size_type pos, typename S::size_type x)
 {
     LIBCPP_ASSERT_NOEXCEPT(s.find_first_not_of(str, pos));
@@ -27,7 +27,7 @@
 }
 
 template <class S>
-void
+TEST_CONSTEXPR_CXX20 void
 test(const S& s, const S& str, typename S::size_type x)
 {
     LIBCPP_ASSERT_NOEXCEPT(s.find_first_not_of(str));
@@ -37,7 +37,7 @@
 }
 
 template <class S>
-void test0()
+TEST_CONSTEXPR_CXX20 void test0()
 {
     test(S(""), S(""), 0, S::npos);
     test(S(""), S("laenf"), 0, S::npos);
@@ -122,7 +122,7 @@
 }
 
 template <class S>
-void test1()
+TEST_CONSTEXPR_CXX20 void test1()
 {
     test(S(""), S(""), S::npos);
     test(S(""), S("laenf"), S::npos);
@@ -142,8 +142,7 @@
     test(S("pniotcfrhqsmgdkjbael"), S("htaobedqikfplcgjsmrn"), S::npos);
 }
 
-int main(int, char**)
-{
+TEST_CONSTEXPR_CXX20 bool test() {
     {
     typedef std::string S;
     test0<S>();
@@ -163,6 +162,15 @@
     assert(s.find_first_not_of({"abc", 1}) == 0);
     }
 #endif
+    
+  return true;
+}
+
+int main() {
+  test();
+#if TEST_STD_VER > 17
+  static_assert(test());
+#endif
 
   return 0;
 }
diff --git a/libcxx/test/std/strings/basic.string/string.ops/string_find.first.of/char_size.pass.cpp b/libcxx/test/std/strings/basic.string/string.ops/string_find.first.of/char_size.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.ops/string_find.first.of/char_size.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.ops/string_find.first.of/char_size.pass.cpp
@@ -17,7 +17,7 @@
 #include "min_allocator.h"
 
 template <class S>
-void
+TEST_CONSTEXPR_CXX20 void
 test(const S& s, typename S::value_type c, typename S::size_type pos,
      typename S::size_type x)
 {
@@ -28,7 +28,7 @@
 }
 
 template <class S>
-void
+TEST_CONSTEXPR_CXX20 void
 test(const S& s, typename S::value_type c, typename S::size_type x)
 {
     LIBCPP_ASSERT_NOEXCEPT(s.find_first_of(c));
@@ -37,8 +37,7 @@
         assert(x < s.size());
 }
 
-int main(int, char**)
-{
+TEST_CONSTEXPR_CXX20 bool test() {
     {
     typedef std::string S;
     test(S(""), 'e', 0, S::npos);
@@ -97,6 +96,15 @@
     test(S("laenfsbridchgotmkqpj"), 'e', 2);
     }
 #endif
+    
+  return true;
+}
+
+int main() {
+  test();
+#if TEST_STD_VER > 17
+  static_assert(test());
+#endif
 
   return 0;
 }
diff --git a/libcxx/test/std/strings/basic.string/string.ops/string_find.first.of/pointer_size.pass.cpp b/libcxx/test/std/strings/basic.string/string.ops/string_find.first.of/pointer_size.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.ops/string_find.first.of/pointer_size.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.ops/string_find.first.of/pointer_size.pass.cpp
@@ -17,7 +17,7 @@
 #include "min_allocator.h"
 
 template <class S>
-void
+TEST_CONSTEXPR_CXX20 void
 test(const S& s, const typename S::value_type* str, typename S::size_type pos,
      typename S::size_type x)
 {
@@ -28,7 +28,7 @@
 }
 
 template <class S>
-void
+TEST_CONSTEXPR_CXX20 void
 test(const S& s, const typename S::value_type* str, typename S::size_type x)
 {
     LIBCPP_ASSERT_NOEXCEPT(s.find_first_of(str));
@@ -38,7 +38,7 @@
 }
 
 template <class S>
-void test0()
+TEST_CONSTEXPR_CXX20 void test0()
 {
     test(S(""), "", 0, S::npos);
     test(S(""), "laenf", 0, S::npos);
@@ -123,7 +123,7 @@
 }
 
 template <class S>
-void test1()
+TEST_CONSTEXPR_CXX20 void test1()
 {
     test(S(""), "", S::npos);
     test(S(""), "laenf", S::npos);
@@ -143,8 +143,7 @@
     test(S("pniotcfrhqsmgdkjbael"), "htaobedqikfplcgjsmrn", 0);
 }
 
-int main(int, char**)
-{
+TEST_CONSTEXPR_CXX20 bool test() {
     {
     typedef std::string S;
     test0<S>();
@@ -157,6 +156,15 @@
     test1<S>();
     }
 #endif
+    
+  return true;
+}
+
+int main() {
+  test();
+#if TEST_STD_VER > 17
+  static_assert(test());
+#endif
 
   return 0;
 }
diff --git a/libcxx/test/std/strings/basic.string/string.ops/string_find.first.of/pointer_size_size.pass.cpp b/libcxx/test/std/strings/basic.string/string.ops/string_find.first.of/pointer_size_size.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.ops/string_find.first.of/pointer_size_size.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.ops/string_find.first.of/pointer_size_size.pass.cpp
@@ -17,7 +17,7 @@
 #include "min_allocator.h"
 
 template <class S>
-void
+TEST_CONSTEXPR_CXX20 void
 test(const S& s, const typename S::value_type* str, typename S::size_type pos,
      typename S::size_type n, typename S::size_type x)
 {
@@ -28,7 +28,7 @@
 }
 
 template <class S>
-void test0()
+TEST_CONSTEXPR_CXX20 void test0()
 {
     test(S(""), "", 0, 0, S::npos);
     test(S(""), "irkhs", 0, 0, S::npos);
@@ -133,7 +133,7 @@
 }
 
 template <class S>
-void test1()
+TEST_CONSTEXPR_CXX20 void test1()
 {
     test(S("gbhqo"), "skqne", 5, 4, S::npos);
     test(S("ktdor"), "kipnf", 5, 5, S::npos);
@@ -238,7 +238,7 @@
 }
 
 template <class S>
-void test2()
+TEST_CONSTEXPR_CXX20 void test2()
 {
     test(S("sdpcilonqj"), "dnjfsagktr", 10, 5, S::npos);
     test(S("gtfbdkqeml"), "nejaktmiqg", 10, 9, S::npos);
@@ -343,7 +343,7 @@
 }
 
 template <class S>
-void test3()
+TEST_CONSTEXPR_CXX20 void test3()
 {
     test(S("pboqganrhedjmltsicfk"), "gbkhdnpoietfcmrslajq", 20, 1, S::npos);
     test(S("klchabsimetjnqgorfpd"), "rtfnmbsglkjaichoqedp", 20, 10, S::npos);
@@ -367,8 +367,7 @@
     test(S("hnbrcplsjfgiktoedmaq"), "qprlsfojamgndekthibc", 21, 20, S::npos);
 }
 
-int main(int, char**)
-{
+TEST_CONSTEXPR_CXX20 bool test() {
     {
     typedef std::string S;
     test0<S>();
@@ -385,6 +384,15 @@
     test3<S>();
     }
 #endif
+    
+  return true;
+}
+
+int main() {
+  test();
+#if TEST_STD_VER > 17
+  static_assert(test());
+#endif
 
   return 0;
 }
diff --git a/libcxx/test/std/strings/basic.string/string.ops/string_find.first.of/string_size.pass.cpp b/libcxx/test/std/strings/basic.string/string.ops/string_find.first.of/string_size.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.ops/string_find.first.of/string_size.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.ops/string_find.first.of/string_size.pass.cpp
@@ -17,7 +17,7 @@
 #include "min_allocator.h"
 
 template <class S>
-void
+TEST_CONSTEXPR_CXX20 void
 test(const S& s, const S& str, typename S::size_type pos, typename S::size_type x)
 {
     LIBCPP_ASSERT_NOEXCEPT(s.find_first_of(str, pos));
@@ -27,7 +27,7 @@
 }
 
 template <class S>
-void
+TEST_CONSTEXPR_CXX20 void
 test(const S& s, const S& str, typename S::size_type x)
 {
     LIBCPP_ASSERT_NOEXCEPT(s.find_first_of(str));
@@ -37,7 +37,7 @@
 }
 
 template <class S>
-void test0()
+TEST_CONSTEXPR_CXX20 void test0()
 {
     test(S(""), S(""), 0, S::npos);
     test(S(""), S("laenf"), 0, S::npos);
@@ -122,7 +122,7 @@
 }
 
 template <class S>
-void test1()
+TEST_CONSTEXPR_CXX20 void test1()
 {
     test(S(""), S(""), S::npos);
     test(S(""), S("laenf"), S::npos);
@@ -142,8 +142,7 @@
     test(S("pniotcfrhqsmgdkjbael"), S("htaobedqikfplcgjsmrn"), 0);
 }
 
-int main(int, char**)
-{
+TEST_CONSTEXPR_CXX20 bool test() {
     {
     typedef std::string S;
     test0<S>();
@@ -163,6 +162,15 @@
     assert(s.find_first_of({"abc", 1}) == std::string::npos);
     }
 #endif
+    
+  return true;
+}
+
+int main() {
+  test();
+#if TEST_STD_VER > 17
+  static_assert(test());
+#endif
 
   return 0;
 }
diff --git a/libcxx/test/std/strings/basic.string/string.ops/string_find.first.of/string_view_size.pass.cpp b/libcxx/test/std/strings/basic.string/string.ops/string_find.first.of/string_view_size.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.ops/string_find.first.of/string_view_size.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.ops/string_find.first.of/string_view_size.pass.cpp
@@ -17,7 +17,7 @@
 #include "min_allocator.h"
 
 template <class S, class SV>
-void
+TEST_CONSTEXPR_CXX20 void
 test(const S& s, SV sv, typename S::size_type pos, typename S::size_type x)
 {
     LIBCPP_ASSERT_NOEXCEPT(s.find_first_of(sv, pos));
@@ -27,7 +27,7 @@
 }
 
 template <class S, class SV>
-void
+TEST_CONSTEXPR_CXX20 void
 test(const S& s, SV sv, typename S::size_type x)
 {
     LIBCPP_ASSERT_NOEXCEPT(s.find_first_of(sv));
@@ -37,7 +37,7 @@
 }
 
 template <class S, class SV>
-void test0()
+TEST_CONSTEXPR_CXX20 void test0()
 {
     test(S(""), SV(""), 0, S::npos);
     test(S(""), SV("laenf"), 0, S::npos);
@@ -122,7 +122,7 @@
 }
 
 template <class S, class SV>
-void test1()
+TEST_CONSTEXPR_CXX20 void test1()
 {
     test(S(""), SV(""), S::npos);
     test(S(""), SV("laenf"), S::npos);
@@ -142,8 +142,7 @@
     test(S("pniotcfrhqsmgdkjbael"), SV("htaobedqikfplcgjsmrn"), 0);
 }
 
-int main(int, char**)
-{
+TEST_CONSTEXPR_CXX20 bool test() {
     {
     typedef std::string S;
     typedef std::string_view SV;
@@ -158,6 +157,15 @@
     test1<S, SV>();
     }
 #endif
+    
+  return true;
+}
+
+int main() {
+  test();
+#if TEST_STD_VER > 17
+  static_assert(test());
+#endif
 
   return 0;
 }
diff --git a/libcxx/test/std/strings/basic.string/string.ops/string_find.last.not.of/char_size.pass.cpp b/libcxx/test/std/strings/basic.string/string.ops/string_find.last.not.of/char_size.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.ops/string_find.last.not.of/char_size.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.ops/string_find.last.not.of/char_size.pass.cpp
@@ -17,7 +17,7 @@
 #include "min_allocator.h"
 
 template <class S>
-void
+TEST_CONSTEXPR_CXX20 void
 test(const S& s, typename S::value_type c, typename S::size_type pos,
      typename S::size_type x)
 {
@@ -28,7 +28,7 @@
 }
 
 template <class S>
-void
+TEST_CONSTEXPR_CXX20 void
 test(const S& s, typename S::value_type c, typename S::size_type x)
 {
     LIBCPP_ASSERT_NOEXCEPT(s.find_last_not_of(c));
@@ -37,8 +37,7 @@
         assert(x < s.size());
 }
 
-int main(int, char**)
-{
+TEST_CONSTEXPR_CXX20 bool test() {
     {
     typedef std::string S;
     test(S(""), 'i', 0, S::npos);
@@ -97,6 +96,15 @@
     test(S("laenfsbridchgotmkqpj"), 'i', 19);
     }
 #endif
+    
+  return true;
+}
+
+int main() {
+  test();
+#if TEST_STD_VER > 17
+  static_assert(test());
+#endif
 
   return 0;
 }
diff --git a/libcxx/test/std/strings/basic.string/string.ops/string_find.last.not.of/pointer_size.pass.cpp b/libcxx/test/std/strings/basic.string/string.ops/string_find.last.not.of/pointer_size.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.ops/string_find.last.not.of/pointer_size.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.ops/string_find.last.not.of/pointer_size.pass.cpp
@@ -17,7 +17,7 @@
 #include "min_allocator.h"
 
 template <class S>
-void
+TEST_CONSTEXPR_CXX20 void
 test(const S& s, const typename S::value_type* str, typename S::size_type pos,
      typename S::size_type x)
 {
@@ -28,7 +28,7 @@
 }
 
 template <class S>
-void
+TEST_CONSTEXPR_CXX20 void
 test(const S& s, const typename S::value_type* str, typename S::size_type x)
 {
     LIBCPP_ASSERT_NOEXCEPT(s.find_last_not_of(str));
@@ -38,7 +38,7 @@
 }
 
 template <class S>
-void test0()
+TEST_CONSTEXPR_CXX20 void test0()
 {
     test(S(""), "", 0, S::npos);
     test(S(""), "laenf", 0, S::npos);
@@ -123,7 +123,7 @@
 }
 
 template <class S>
-void test1()
+TEST_CONSTEXPR_CXX20 void test1()
 {
     test(S(""), "", S::npos);
     test(S(""), "laenf", S::npos);
@@ -143,8 +143,7 @@
     test(S("pniotcfrhqsmgdkjbael"), "htaobedqikfplcgjsmrn", S::npos);
 }
 
-int main(int, char**)
-{
+TEST_CONSTEXPR_CXX20 bool test() {
     {
     typedef std::string S;
     test0<S>();
@@ -157,6 +156,15 @@
     test1<S>();
     }
 #endif
+    
+  return true;
+}
+
+int main() {
+  test();
+#if TEST_STD_VER > 17
+  static_assert(test());
+#endif
 
   return 0;
 }
diff --git a/libcxx/test/std/strings/basic.string/string.ops/string_find.last.not.of/pointer_size_size.pass.cpp b/libcxx/test/std/strings/basic.string/string.ops/string_find.last.not.of/pointer_size_size.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.ops/string_find.last.not.of/pointer_size_size.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.ops/string_find.last.not.of/pointer_size_size.pass.cpp
@@ -17,7 +17,7 @@
 #include "min_allocator.h"
 
 template <class S>
-void
+TEST_CONSTEXPR_CXX20 void
 test(const S& s, const typename S::value_type* str, typename S::size_type pos,
      typename S::size_type n, typename S::size_type x)
 {
@@ -28,7 +28,7 @@
 }
 
 template <class S>
-void test0()
+TEST_CONSTEXPR_CXX20 void test0()
 {
     test(S(""), "", 0, 0, S::npos);
     test(S(""), "irkhs", 0, 0, S::npos);
@@ -133,7 +133,7 @@
 }
 
 template <class S>
-void test1()
+TEST_CONSTEXPR_CXX20 void test1()
 {
     test(S("gbhqo"), "skqne", 5, 4, 4);
     test(S("ktdor"), "kipnf", 5, 5, 4);
@@ -238,7 +238,7 @@
 }
 
 template <class S>
-void test2()
+TEST_CONSTEXPR_CXX20 void test2()
 {
     test(S("sdpcilonqj"), "dnjfsagktr", 10, 5, 8);
     test(S("gtfbdkqeml"), "nejaktmiqg", 10, 9, 9);
@@ -343,7 +343,7 @@
 }
 
 template <class S>
-void test3()
+TEST_CONSTEXPR_CXX20 void test3()
 {
     test(S("pboqganrhedjmltsicfk"), "gbkhdnpoietfcmrslajq", 20, 1, 19);
     test(S("klchabsimetjnqgorfpd"), "rtfnmbsglkjaichoqedp", 20, 10, 19);
@@ -367,8 +367,7 @@
     test(S("hnbrcplsjfgiktoedmaq"), "qprlsfojamgndekthibc", 21, 20, S::npos);
 }
 
-int main(int, char**)
-{
+TEST_CONSTEXPR_CXX20 bool test() {
     {
     typedef std::string S;
     test0<S>();
@@ -385,6 +384,15 @@
     test3<S>();
     }
 #endif
+    
+  return true;
+}
+
+int main() {
+  test();
+#if TEST_STD_VER > 17
+  static_assert(test());
+#endif
 
   return 0;
 }
diff --git a/libcxx/test/std/strings/basic.string/string.ops/string_find.last.not.of/string_size.pass.cpp b/libcxx/test/std/strings/basic.string/string.ops/string_find.last.not.of/string_size.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.ops/string_find.last.not.of/string_size.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.ops/string_find.last.not.of/string_size.pass.cpp
@@ -17,7 +17,7 @@
 #include "min_allocator.h"
 
 template <class S>
-void
+TEST_CONSTEXPR_CXX20 void
 test(const S& s, const S& str, typename S::size_type pos, typename S::size_type x)
 {
     LIBCPP_ASSERT_NOEXCEPT(s.find_last_not_of(str, pos));
@@ -27,7 +27,7 @@
 }
 
 template <class S>
-void
+TEST_CONSTEXPR_CXX20 void
 test(const S& s, const S& str, typename S::size_type x)
 {
     LIBCPP_ASSERT_NOEXCEPT(s.find_last_not_of(str));
@@ -37,7 +37,7 @@
 }
 
 template <class S>
-void test0()
+TEST_CONSTEXPR_CXX20 void test0()
 {
     test(S(""), S(""), 0, S::npos);
     test(S(""), S("laenf"), 0, S::npos);
@@ -122,7 +122,7 @@
 }
 
 template <class S>
-void test1()
+TEST_CONSTEXPR_CXX20 void test1()
 {
     test(S(""), S(""), S::npos);
     test(S(""), S("laenf"), S::npos);
@@ -142,8 +142,7 @@
     test(S("pniotcfrhqsmgdkjbael"), S("htaobedqikfplcgjsmrn"), S::npos);
 }
 
-int main(int, char**)
-{
+TEST_CONSTEXPR_CXX20 bool test() {
     {
     typedef std::string S;
     test0<S>();
@@ -163,6 +162,15 @@
     assert(s.find_last_not_of({"abc", 1}) == s.size() - 1);
     }
 #endif
+    
+  return true;
+}
+
+int main() {
+  test();
+#if TEST_STD_VER > 17
+  static_assert(test());
+#endif
 
   return 0;
 }
diff --git a/libcxx/test/std/strings/basic.string/string.ops/string_find.last.not.of/string_view_size.pass.cpp b/libcxx/test/std/strings/basic.string/string.ops/string_find.last.not.of/string_view_size.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.ops/string_find.last.not.of/string_view_size.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.ops/string_find.last.not.of/string_view_size.pass.cpp
@@ -17,7 +17,7 @@
 #include "min_allocator.h"
 
 template <class S, class SV>
-void
+TEST_CONSTEXPR_CXX20 void
 test(const S& s, SV sv, typename S::size_type pos, typename S::size_type x)
 {
     LIBCPP_ASSERT_NOEXCEPT(s.find_last_not_of(sv, pos));
@@ -27,7 +27,7 @@
 }
 
 template <class S, class SV>
-void
+TEST_CONSTEXPR_CXX20 void
 test(const S& s, SV sv, typename S::size_type x)
 {
     LIBCPP_ASSERT_NOEXCEPT(s.find_last_not_of(sv));
@@ -37,7 +37,7 @@
 }
 
 template <class S, class SV>
-void test0()
+TEST_CONSTEXPR_CXX20 void test0()
 {
     test(S(""), SV(""), 0, S::npos);
     test(S(""), SV("laenf"), 0, S::npos);
@@ -122,7 +122,7 @@
 }
 
 template <class S, class SV>
-void test1()
+TEST_CONSTEXPR_CXX20 void test1()
 {
     test(S(""), SV(""), S::npos);
     test(S(""), SV("laenf"), S::npos);
@@ -142,8 +142,7 @@
     test(S("pniotcfrhqsmgdkjbael"), SV("htaobedqikfplcgjsmrn"), S::npos);
 }
 
-int main(int, char**)
-{
+TEST_CONSTEXPR_CXX20 bool test() {
     {
     typedef std::string S;
     typedef std::string_view SV;
@@ -158,6 +157,15 @@
 //     test1<S, SV>();
     }
 #endif
+    
+  return true;
+}
+
+int main() {
+  test();
+#if TEST_STD_VER > 17
+  static_assert(test());
+#endif
 
   return 0;
 }
diff --git a/libcxx/test/std/strings/basic.string/string.ops/string_find.last.of/char_size.pass.cpp b/libcxx/test/std/strings/basic.string/string.ops/string_find.last.of/char_size.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.ops/string_find.last.of/char_size.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.ops/string_find.last.of/char_size.pass.cpp
@@ -17,7 +17,7 @@
 #include "min_allocator.h"
 
 template <class S>
-void
+TEST_CONSTEXPR_CXX20 void
 test(const S& s, typename S::value_type c, typename S::size_type pos,
      typename S::size_type x)
 {
@@ -28,7 +28,7 @@
 }
 
 template <class S>
-void
+TEST_CONSTEXPR_CXX20 void
 test(const S& s, typename S::value_type c, typename S::size_type x)
 {
     LIBCPP_ASSERT_NOEXCEPT(s.find_last_of(c));
@@ -37,8 +37,7 @@
         assert(x < s.size());
 }
 
-int main(int, char**)
-{
+TEST_CONSTEXPR_CXX20 bool test() {
     {
     typedef std::string S;
     test(S(""), 'm', 0, S::npos);
@@ -97,6 +96,15 @@
     test(S("laenfsbridchgotmkqpj"), 'm', 15);
     }
 #endif
+    
+  return true;
+}
+
+int main() {
+  test();
+#if TEST_STD_VER > 17
+  static_assert(test());
+#endif
 
   return 0;
 }
diff --git a/libcxx/test/std/strings/basic.string/string.ops/string_find.last.of/pointer_size.pass.cpp b/libcxx/test/std/strings/basic.string/string.ops/string_find.last.of/pointer_size.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.ops/string_find.last.of/pointer_size.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.ops/string_find.last.of/pointer_size.pass.cpp
@@ -17,7 +17,7 @@
 #include "min_allocator.h"
 
 template <class S>
-void
+TEST_CONSTEXPR_CXX20 void
 test(const S& s, const typename S::value_type* str, typename S::size_type pos,
      typename S::size_type x)
 {
@@ -28,7 +28,7 @@
 }
 
 template <class S>
-void
+TEST_CONSTEXPR_CXX20 void
 test(const S& s, const typename S::value_type* str, typename S::size_type x)
 {
     LIBCPP_ASSERT_NOEXCEPT(s.find_last_of(str));
@@ -38,7 +38,7 @@
 }
 
 template <class S>
-void test0()
+TEST_CONSTEXPR_CXX20 void test0()
 {
     test(S(""), "", 0, S::npos);
     test(S(""), "laenf", 0, S::npos);
@@ -123,7 +123,7 @@
 }
 
 template <class S>
-void test1()
+TEST_CONSTEXPR_CXX20 void test1()
 {
     test(S(""), "", S::npos);
     test(S(""), "laenf", S::npos);
@@ -143,8 +143,7 @@
     test(S("pniotcfrhqsmgdkjbael"), "htaobedqikfplcgjsmrn", 19);
 }
 
-int main(int, char**)
-{
+TEST_CONSTEXPR_CXX20 bool test() {
     {
     typedef std::string S;
     test0<S>();
@@ -157,6 +156,15 @@
     test1<S>();
     }
 #endif
+    
+  return true;
+}
+
+int main() {
+  test();
+#if TEST_STD_VER > 17
+  static_assert(test());
+#endif
 
   return 0;
 }
diff --git a/libcxx/test/std/strings/basic.string/string.ops/string_find.last.of/pointer_size_size.pass.cpp b/libcxx/test/std/strings/basic.string/string.ops/string_find.last.of/pointer_size_size.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.ops/string_find.last.of/pointer_size_size.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.ops/string_find.last.of/pointer_size_size.pass.cpp
@@ -17,7 +17,7 @@
 #include "min_allocator.h"
 
 template <class S>
-void
+TEST_CONSTEXPR_CXX20 void
 test(const S& s, const typename S::value_type* str, typename S::size_type pos,
      typename S::size_type n, typename S::size_type x)
 {
@@ -28,7 +28,7 @@
 }
 
 template <class S>
-void test0()
+TEST_CONSTEXPR_CXX20 void test0()
 {
     test(S(""), "", 0, 0, S::npos);
     test(S(""), "irkhs", 0, 0, S::npos);
@@ -133,7 +133,7 @@
 }
 
 template <class S>
-void test1()
+TEST_CONSTEXPR_CXX20 void test1()
 {
     test(S("gbhqo"), "skqne", 5, 4, 3);
     test(S("ktdor"), "kipnf", 5, 5, 0);
@@ -238,7 +238,7 @@
 }
 
 template <class S>
-void test2()
+TEST_CONSTEXPR_CXX20 void test2()
 {
     test(S("sdpcilonqj"), "dnjfsagktr", 10, 5, 9);
     test(S("gtfbdkqeml"), "nejaktmiqg", 10, 9, 8);
@@ -343,7 +343,7 @@
 }
 
 template <class S>
-void test3()
+TEST_CONSTEXPR_CXX20 void test3()
 {
     test(S("pboqganrhedjmltsicfk"), "gbkhdnpoietfcmrslajq", 20, 1, 4);
     test(S("klchabsimetjnqgorfpd"), "rtfnmbsglkjaichoqedp", 20, 10, 17);
@@ -367,8 +367,7 @@
     test(S("hnbrcplsjfgiktoedmaq"), "qprlsfojamgndekthibc", 21, 20, 19);
 }
 
-int main(int, char**)
-{
+TEST_CONSTEXPR_CXX20 bool test() {
     {
     typedef std::string S;
     test0<S>();
@@ -385,6 +384,15 @@
     test3<S>();
     }
 #endif
+    
+  return true;
+}
+
+int main() {
+  test();
+#if TEST_STD_VER > 17
+  static_assert(test());
+#endif
 
   return 0;
 }
diff --git a/libcxx/test/std/strings/basic.string/string.ops/string_find.last.of/string_size.pass.cpp b/libcxx/test/std/strings/basic.string/string.ops/string_find.last.of/string_size.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.ops/string_find.last.of/string_size.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.ops/string_find.last.of/string_size.pass.cpp
@@ -17,7 +17,7 @@
 #include "min_allocator.h"
 
 template <class S>
-void
+TEST_CONSTEXPR_CXX20 void
 test(const S& s, const S& str, typename S::size_type pos, typename S::size_type x)
 {
     LIBCPP_ASSERT_NOEXCEPT(s.find_last_of(str, pos));
@@ -27,7 +27,7 @@
 }
 
 template <class S>
-void
+TEST_CONSTEXPR_CXX20 void
 test(const S& s, const S& str, typename S::size_type x)
 {
     LIBCPP_ASSERT_NOEXCEPT(s.find_last_of(str));
@@ -37,7 +37,7 @@
 }
 
 template <class S>
-void test0()
+TEST_CONSTEXPR_CXX20 void test0()
 {
     test(S(""), S(""), 0, S::npos);
     test(S(""), S("laenf"), 0, S::npos);
@@ -122,7 +122,7 @@
 }
 
 template <class S>
-void test1()
+TEST_CONSTEXPR_CXX20 void test1()
 {
     test(S(""), S(""), S::npos);
     test(S(""), S("laenf"), S::npos);
@@ -142,8 +142,7 @@
     test(S("pniotcfrhqsmgdkjbael"), S("htaobedqikfplcgjsmrn"), 19);
 }
 
-int main(int, char**)
-{
+TEST_CONSTEXPR_CXX20 bool test() {
     {
     typedef std::string S;
     test0<S>();
@@ -163,6 +162,15 @@
     assert(s.find_last_of({"abc", 1}) == std::string::npos);
     }
 #endif
+    
+  return true;
+}
+
+int main() {
+  test();
+#if TEST_STD_VER > 17
+  static_assert(test());
+#endif
 
   return 0;
 }
diff --git a/libcxx/test/std/strings/basic.string/string.ops/string_find.last.of/string_view_size.pass.cpp b/libcxx/test/std/strings/basic.string/string.ops/string_find.last.of/string_view_size.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.ops/string_find.last.of/string_view_size.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.ops/string_find.last.of/string_view_size.pass.cpp
@@ -17,7 +17,7 @@
 #include "min_allocator.h"
 
 template <class S, class SV>
-void
+TEST_CONSTEXPR_CXX20 void
 test(const S& s, SV sv, typename S::size_type pos, typename S::size_type x)
 {
     LIBCPP_ASSERT_NOEXCEPT(s.find_last_of(sv, pos));
@@ -27,7 +27,7 @@
 }
 
 template <class S, class SV>
-void
+TEST_CONSTEXPR_CXX20 void
 test(const S& s, SV sv, typename S::size_type x)
 {
     LIBCPP_ASSERT_NOEXCEPT(s.find_last_of(sv));
@@ -37,7 +37,7 @@
 }
 
 template <class S, class SV>
-void test0()
+TEST_CONSTEXPR_CXX20 void test0()
 {
     test(S(""), SV(""), 0, S::npos);
     test(S(""), SV("laenf"), 0, S::npos);
@@ -122,7 +122,7 @@
 }
 
 template <class S, class SV>
-void test1()
+TEST_CONSTEXPR_CXX20 void test1()
 {
     test(S(""), SV(""), S::npos);
     test(S(""), SV("laenf"), S::npos);
@@ -142,8 +142,7 @@
     test(S("pniotcfrhqsmgdkjbael"), SV("htaobedqikfplcgjsmrn"), 19);
 }
 
-int main(int, char**)
-{
+TEST_CONSTEXPR_CXX20 bool test() {
     {
     typedef std::string S;
     typedef std::string_view SV;
@@ -158,6 +157,15 @@
     test1<S, SV>();
     }
 #endif
+    
+  return true;
+}
+
+int main() {
+  test();
+#if TEST_STD_VER > 17
+  static_assert(test());
+#endif
 
   return 0;
 }
diff --git a/libcxx/test/std/strings/basic.string/string.ops/string_find/char_size.pass.cpp b/libcxx/test/std/strings/basic.string/string.ops/string_find/char_size.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.ops/string_find/char_size.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.ops/string_find/char_size.pass.cpp
@@ -17,7 +17,7 @@
 #include "min_allocator.h"
 
 template <class S>
-void
+TEST_CONSTEXPR_CXX20 void
 test(const S& s, typename S::value_type c, typename S::size_type pos,
      typename S::size_type x)
 {
@@ -28,7 +28,7 @@
 }
 
 template <class S>
-void
+TEST_CONSTEXPR_CXX20 void
 test(const S& s, typename S::value_type c, typename S::size_type x)
 {
     LIBCPP_ASSERT_NOEXCEPT(s.find(c));
@@ -37,8 +37,7 @@
         assert(0 <= x && x + 1 <= s.size());
 }
 
-int main(int, char**)
-{
+TEST_CONSTEXPR_CXX20 bool test() {
     {
     typedef std::string S;
     test(S(""), 'c', 0, S::npos);
@@ -97,6 +96,15 @@
     test(S("abcdeabcdeabcdeabcde"), 'c', 2);
     }
 #endif
+    
+  return true;
+}
+
+int main() {
+  test();
+#if TEST_STD_VER > 17
+  static_assert(test());
+#endif
 
   return 0;
 }
diff --git a/libcxx/test/std/strings/basic.string/string.ops/string_find/pointer_size.pass.cpp b/libcxx/test/std/strings/basic.string/string.ops/string_find/pointer_size.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.ops/string_find/pointer_size.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.ops/string_find/pointer_size.pass.cpp
@@ -17,7 +17,7 @@
 #include "min_allocator.h"
 
 template <class S>
-void
+TEST_CONSTEXPR_CXX20 void
 test(const S& s, const typename S::value_type* str, typename S::size_type pos,
      typename S::size_type x)
 {
@@ -31,7 +31,7 @@
 }
 
 template <class S>
-void
+TEST_CONSTEXPR_CXX20 void
 test(const S& s, const typename S::value_type* str, typename S::size_type x)
 {
     LIBCPP_ASSERT_NOEXCEPT(s.find(str));
@@ -44,7 +44,7 @@
 }
 
 template <class S>
-void test0()
+TEST_CONSTEXPR_CXX20 void test0()
 {
     test(S(""), "", 0, 0);
     test(S(""), "abcde", 0, S::npos);
@@ -129,7 +129,7 @@
 }
 
 template <class S>
-void test1()
+TEST_CONSTEXPR_CXX20 void test1()
 {
     test(S(""), "", 0);
     test(S(""), "abcde", S::npos);
@@ -149,8 +149,7 @@
     test(S("abcdeabcdeabcdeabcde"), "abcdeabcdeabcdeabcde", 0);
 }
 
-int main(int, char**)
-{
+TEST_CONSTEXPR_CXX20 bool test() {
     {
     typedef std::string S;
     test0<S>();
@@ -163,6 +162,15 @@
     test1<S>();
     }
 #endif
+    
+  return true;
+}
+
+int main() {
+  test();
+#if TEST_STD_VER > 17
+  static_assert(test());
+#endif
 
   return 0;
 }
diff --git a/libcxx/test/std/strings/basic.string/string.ops/string_find/pointer_size_size.pass.cpp b/libcxx/test/std/strings/basic.string/string.ops/string_find/pointer_size_size.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.ops/string_find/pointer_size_size.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.ops/string_find/pointer_size_size.pass.cpp
@@ -17,7 +17,7 @@
 #include "min_allocator.h"
 
 template <class S>
-void
+TEST_CONSTEXPR_CXX20 void
 test(const S& s, const typename S::value_type* str, typename S::size_type pos,
      typename S::size_type n, typename S::size_type x)
 {
@@ -28,7 +28,7 @@
 }
 
 template <class S>
-void test0()
+TEST_CONSTEXPR_CXX20 void test0()
 {
     test(S(""), "", 0, 0, 0);
     test(S(""), "abcde", 0, 0, 0);
@@ -133,7 +133,7 @@
 }
 
 template <class S>
-void test1()
+TEST_CONSTEXPR_CXX20 void test1()
 {
     test(S("abcde"), "abcde", 5, 4, S::npos);
     test(S("abcde"), "abcde", 5, 5, S::npos);
@@ -238,7 +238,7 @@
 }
 
 template <class S>
-void test2()
+TEST_CONSTEXPR_CXX20 void test2()
 {
     test(S("abcdeabcde"), "abcdeabcde", 10, 5, S::npos);
     test(S("abcdeabcde"), "abcdeabcde", 10, 9, S::npos);
@@ -343,7 +343,7 @@
 }
 
 template <class S>
-void test3()
+TEST_CONSTEXPR_CXX20 void test3()
 {
     test(S("abcdeabcdeabcdeabcde"), "abcdeabcdeabcdeabcde", 20, 1, S::npos);
     test(S("abcdeabcdeabcdeabcde"), "abcdeabcdeabcdeabcde", 20, 10, S::npos);
@@ -367,8 +367,7 @@
     test(S("abcdeabcdeabcdeabcde"), "abcdeabcdeabcdeabcde", 21, 20, S::npos);
 }
 
-int main(int, char**)
-{
+TEST_CONSTEXPR_CXX20 bool test() {
     {
     typedef std::string S;
     test0<S>();
@@ -385,6 +384,15 @@
     test3<S>();
     }
 #endif
+    
+  return true;
+}
+
+int main() {
+  test();
+#if TEST_STD_VER > 17
+  static_assert(test());
+#endif
 
   return 0;
 }
diff --git a/libcxx/test/std/strings/basic.string/string.ops/string_find/string_size.pass.cpp b/libcxx/test/std/strings/basic.string/string.ops/string_find/string_size.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.ops/string_find/string_size.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.ops/string_find/string_size.pass.cpp
@@ -17,7 +17,7 @@
 #include "min_allocator.h"
 
 template <class S>
-void
+TEST_CONSTEXPR_CXX20 void
 test(const S& s, const S& str, typename S::size_type pos, typename S::size_type x)
 {
     LIBCPP_ASSERT_NOEXCEPT(s.find(str, pos));
@@ -27,7 +27,7 @@
 }
 
 template <class S>
-void
+TEST_CONSTEXPR_CXX20 void
 test(const S& s, const S& str, typename S::size_type x)
 {
     LIBCPP_ASSERT_NOEXCEPT(s.find(str));
@@ -37,7 +37,7 @@
 }
 
 template <class S>
-void test0()
+TEST_CONSTEXPR_CXX20 void test0()
 {
     test(S(""), S(""), 0, 0);
     test(S(""), S("abcde"), 0, S::npos);
@@ -122,7 +122,7 @@
 }
 
 template <class S>
-void test1()
+TEST_CONSTEXPR_CXX20 void test1()
 {
     test(S(""), S(""), 0);
     test(S(""), S("abcde"), S::npos);
@@ -142,8 +142,7 @@
     test(S("abcdeabcdeabcdeabcde"), S("abcdeabcdeabcdeabcde"), 0);
 }
 
-int main(int, char**)
-{
+TEST_CONSTEXPR_CXX20 bool test() {
     {
     typedef std::string S;
     test0<S>();
@@ -163,6 +162,15 @@
     assert(s.find({"abc", 1}) == std::string::npos);
     }
 #endif
+    
+  return true;
+}
+
+int main() {
+  test();
+#if TEST_STD_VER > 17
+  static_assert(test());
+#endif
 
   return 0;
 }
diff --git a/libcxx/test/std/strings/basic.string/string.ops/string_find/string_view_size.pass.cpp b/libcxx/test/std/strings/basic.string/string.ops/string_find/string_view_size.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.ops/string_find/string_view_size.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.ops/string_find/string_view_size.pass.cpp
@@ -17,7 +17,7 @@
 #include "min_allocator.h"
 
 template <class S, class SV>
-void
+TEST_CONSTEXPR_CXX20 void
 test(const S& s, SV sv, typename S::size_type pos, typename S::size_type x)
 {
     LIBCPP_ASSERT_NOEXCEPT(s.find(sv, pos));
@@ -27,7 +27,7 @@
 }
 
 template <class S, class SV>
-void
+TEST_CONSTEXPR_CXX20 void
 test(const S& s, SV sv, typename S::size_type x)
 {
     LIBCPP_ASSERT_NOEXCEPT(s.find(sv));
@@ -37,7 +37,7 @@
 }
 
 template <class S, class SV>
-void test0()
+TEST_CONSTEXPR_CXX20 void test0()
 {
     test(S(""), SV(""), 0, 0);
     test(S(""), SV("abcde"), 0, S::npos);
@@ -122,7 +122,7 @@
 }
 
 template <class S, class SV>
-void test1()
+TEST_CONSTEXPR_CXX20 void test1()
 {
     test(S(""), SV(""), 0);
     test(S(""), SV("abcde"), S::npos);
@@ -142,8 +142,7 @@
     test(S("abcdeabcdeabcdeabcde"), SV("abcdeabcdeabcdeabcde"), 0);
 }
 
-int main(int, char**)
-{
+TEST_CONSTEXPR_CXX20 bool test() {
     {
     typedef std::string S;
     typedef std::string_view SV;
@@ -158,6 +157,15 @@
     test1<S, SV>();
     }
 #endif
+    
+  return true;
+}
+
+int main() {
+  test();
+#if TEST_STD_VER > 17
+  static_assert(test());
+#endif
 
   return 0;
 }
diff --git a/libcxx/test/std/strings/basic.string/string.ops/string_rfind/char_size.pass.cpp b/libcxx/test/std/strings/basic.string/string.ops/string_rfind/char_size.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.ops/string_rfind/char_size.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.ops/string_rfind/char_size.pass.cpp
@@ -17,7 +17,7 @@
 #include "min_allocator.h"
 
 template <class S>
-void
+TEST_CONSTEXPR_CXX20 void
 test(const S& s, typename S::value_type c, typename S::size_type pos,
      typename S::size_type x)
 {
@@ -28,7 +28,7 @@
 }
 
 template <class S>
-void
+TEST_CONSTEXPR_CXX20 void
 test(const S& s, typename S::value_type c, typename S::size_type x)
 {
     LIBCPP_ASSERT_NOEXCEPT(s.rfind(c));
@@ -37,8 +37,7 @@
         assert(x + 1 <= s.size());
 }
 
-int main(int, char**)
-{
+TEST_CONSTEXPR_CXX20 bool test() {
     {
     typedef std::string S;
     test(S(""), 'b', 0, S::npos);
@@ -97,6 +96,15 @@
     test(S("abcdeabcdeabcdeabcde"), 'b', 16);
     }
 #endif
+    
+  return true;
+}
+
+int main() {
+  test();
+#if TEST_STD_VER > 17
+  static_assert(test());
+#endif
 
   return 0;
 }
diff --git a/libcxx/test/std/strings/basic.string/string.ops/string_rfind/pointer_size.pass.cpp b/libcxx/test/std/strings/basic.string/string.ops/string_rfind/pointer_size.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.ops/string_rfind/pointer_size.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.ops/string_rfind/pointer_size.pass.cpp
@@ -17,7 +17,7 @@
 #include "min_allocator.h"
 
 template <class S>
-void
+TEST_CONSTEXPR_CXX20 void
 test(const S& s, const typename S::value_type* str, typename S::size_type pos,
      typename S::size_type x)
 {
@@ -31,7 +31,7 @@
 }
 
 template <class S>
-void
+TEST_CONSTEXPR_CXX20 void
 test(const S& s, const typename S::value_type* str, typename S::size_type x)
 {
     LIBCPP_ASSERT_NOEXCEPT(s.rfind(str));
@@ -45,7 +45,7 @@
 }
 
 template <class S>
-void test0()
+TEST_CONSTEXPR_CXX20 void test0()
 {
     test(S(""), "", 0, 0);
     test(S(""), "abcde", 0, S::npos);
@@ -130,7 +130,7 @@
 }
 
 template <class S>
-void test1()
+TEST_CONSTEXPR_CXX20 void test1()
 {
     test(S(""), "", 0);
     test(S(""), "abcde", S::npos);
@@ -150,8 +150,7 @@
     test(S("abcdeabcdeabcdeabcde"), "abcdeabcdeabcdeabcde", 0);
 }
 
-int main(int, char**)
-{
+TEST_CONSTEXPR_CXX20 bool test() {
     {
     typedef std::string S;
     test0<S>();
@@ -164,6 +163,15 @@
     test1<S>();
     }
 #endif
+    
+  return true;
+}
+
+int main() {
+  test();
+#if TEST_STD_VER > 17
+  static_assert(test());
+#endif
 
   return 0;
 }
diff --git a/libcxx/test/std/strings/basic.string/string.ops/string_rfind/pointer_size_size.pass.cpp b/libcxx/test/std/strings/basic.string/string.ops/string_rfind/pointer_size_size.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.ops/string_rfind/pointer_size_size.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.ops/string_rfind/pointer_size_size.pass.cpp
@@ -17,7 +17,7 @@
 #include "min_allocator.h"
 
 template <class S>
-void
+TEST_CONSTEXPR_CXX20 void
 test(const S& s, const typename S::value_type* str, typename S::size_type pos,
       typename S::size_type n, typename S::size_type x)
 {
@@ -28,7 +28,7 @@
 }
 
 template <class S>
-void test0()
+TEST_CONSTEXPR_CXX20 void test0()
 {
     test(S(""), "", 0, 0, 0);
     test(S(""), "abcde", 0, 0, 0);
@@ -133,7 +133,7 @@
 }
 
 template <class S>
-void test1()
+TEST_CONSTEXPR_CXX20 void test1()
 {
     test(S("abcde"), "abcde", 5, 4, 0);
     test(S("abcde"), "abcde", 5, 5, 0);
@@ -238,7 +238,7 @@
 }
 
 template <class S>
-void test2()
+TEST_CONSTEXPR_CXX20 void test2()
 {
     test(S("abcdeabcde"), "abcdeabcde", 10, 5, 5);
     test(S("abcdeabcde"), "abcdeabcde", 10, 9, 0);
@@ -343,7 +343,7 @@
 }
 
 template <class S>
-void test3()
+TEST_CONSTEXPR_CXX20 void test3()
 {
     test(S("abcdeabcdeabcdeabcde"), "abcdeabcdeabcdeabcde", 20, 1, 15);
     test(S("abcdeabcdeabcdeabcde"), "abcdeabcdeabcdeabcde", 20, 10, 10);
@@ -367,8 +367,7 @@
     test(S("abcdeabcdeabcdeabcde"), "abcdeabcdeabcdeabcde", 21, 20, 0);
 }
 
-int main(int, char**)
-{
+TEST_CONSTEXPR_CXX20 bool test() {
     {
     typedef std::string S;
     test0<S>();
@@ -385,6 +384,15 @@
     test3<S>();
     }
 #endif
+    
+  return true;
+}
+
+int main() {
+  test();
+#if TEST_STD_VER > 17
+  static_assert(test());
+#endif
 
   return 0;
 }
diff --git a/libcxx/test/std/strings/basic.string/string.ops/string_rfind/string_size.pass.cpp b/libcxx/test/std/strings/basic.string/string.ops/string_rfind/string_size.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.ops/string_rfind/string_size.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.ops/string_rfind/string_size.pass.cpp
@@ -17,7 +17,7 @@
 #include "min_allocator.h"
 
 template <class S>
-void
+TEST_CONSTEXPR_CXX20 void
 test(const S& s, const S& str, typename S::size_type pos, typename S::size_type x)
 {
     LIBCPP_ASSERT_NOEXCEPT(s.rfind(str, pos));
@@ -27,7 +27,7 @@
 }
 
 template <class S>
-void
+TEST_CONSTEXPR_CXX20 void
 test(const S& s, const S& str, typename S::size_type x)
 {
     LIBCPP_ASSERT_NOEXCEPT(s.rfind(str));
@@ -37,7 +37,7 @@
 }
 
 template <class S>
-void test0()
+TEST_CONSTEXPR_CXX20 void test0()
 {
     test(S(""), S(""), 0, 0);
     test(S(""), S("abcde"), 0, S::npos);
@@ -122,7 +122,7 @@
 }
 
 template <class S>
-void test1()
+TEST_CONSTEXPR_CXX20 void test1()
 {
     test(S(""), S(""), 0);
     test(S(""), S("abcde"), S::npos);
@@ -142,8 +142,7 @@
     test(S("abcdeabcdeabcdeabcde"), S("abcdeabcdeabcdeabcde"), 0);
 }
 
-int main(int, char**)
-{
+TEST_CONSTEXPR_CXX20 bool test() {
     {
     typedef std::string S;
     test0<S>();
@@ -163,6 +162,15 @@
     assert(s.rfind({"abc", 1}) == std::string::npos);
     }
 #endif
+    
+  return true;
+}
+
+int main() {
+  test();
+#if TEST_STD_VER > 17
+  static_assert(test());
+#endif
 
   return 0;
 }
diff --git a/libcxx/test/std/strings/basic.string/string.ops/string_rfind/string_view_size.pass.cpp b/libcxx/test/std/strings/basic.string/string.ops/string_rfind/string_view_size.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.ops/string_rfind/string_view_size.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.ops/string_rfind/string_view_size.pass.cpp
@@ -17,7 +17,7 @@
 #include "min_allocator.h"
 
 template <class S, class SV>
-void
+TEST_CONSTEXPR_CXX20 void
 test(const S& s, SV sv, typename S::size_type pos, typename S::size_type x)
 {
     LIBCPP_ASSERT_NOEXCEPT(s.rfind(sv, pos));
@@ -27,7 +27,7 @@
 }
 
 template <class S, class SV>
-void
+TEST_CONSTEXPR_CXX20 void
 test(const S& s, SV sv, typename S::size_type x)
 {
     LIBCPP_ASSERT_NOEXCEPT(s.rfind(sv));
@@ -37,7 +37,7 @@
 }
 
 template <class S, class SV>
-void test0()
+TEST_CONSTEXPR_CXX20 void test0()
 {
     test(S(""), SV(""), 0, 0);
     test(S(""), SV("abcde"), 0, S::npos);
@@ -122,7 +122,7 @@
 }
 
 template <class S, class SV>
-void test1()
+TEST_CONSTEXPR_CXX20 void test1()
 {
     test(S(""), SV(""), 0);
     test(S(""), SV("abcde"), S::npos);
@@ -142,8 +142,7 @@
     test(S("abcdeabcdeabcdeabcde"), SV("abcdeabcdeabcdeabcde"), 0);
 }
 
-int main(int, char**)
-{
+TEST_CONSTEXPR_CXX20 bool test() {
     {
     typedef std::string S;
     typedef std::string_view SV;
@@ -158,6 +157,15 @@
     test1<S, SV>();
     }
 #endif
+    
+  return true;
+}
+
+int main() {
+  test();
+#if TEST_STD_VER > 17
+  static_assert(test());
+#endif
 
   return 0;
 }
diff --git a/libcxx/test/std/strings/basic.string/string.ops/string_substr/substr.pass.cpp b/libcxx/test/std/strings/basic.string/string.ops/string_substr/substr.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.ops/string_substr/substr.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.ops/string_substr/substr.pass.cpp
@@ -19,7 +19,7 @@
 #include "min_allocator.h"
 
 template <class S>
-void
+TEST_CONSTEXPR_CXX20 void
 test(const S& s, typename S::size_type pos, typename S::size_type n)
 {
     if (pos <= s.size())
@@ -32,7 +32,7 @@
         assert(S::traits_type::compare(s.data()+pos, str.data(), rlen) == 0);
     }
 #ifndef TEST_HAS_NO_EXCEPTIONS
-    else
+    else if (!TEST_IS_CONSTANT_EVALUATED)
     {
         try
         {
@@ -47,8 +47,7 @@
 #endif
 }
 
-int main(int, char**)
-{
+TEST_CONSTEXPR_CXX20 bool test() {
     {
     typedef std::string S;
     test(S(""), 0, 0);
@@ -173,6 +172,15 @@
     test(S("dplqartnfgejichmoskb"), 21, 0);
     }
 #endif
+    
+  return true;
+}
+
+int main() {
+  test();
+#if TEST_STD_VER > 17
+  static_assert(test());
+#endif
 
   return 0;
 }
diff --git a/libcxx/test/std/strings/basic.string/string.require/contiguous.pass.cpp b/libcxx/test/std/strings/basic.string/string.require/contiguous.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.require/contiguous.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.require/contiguous.pass.cpp
@@ -19,14 +19,13 @@
 
 
 template <class C>
-void test_contiguous ( const C &c )
+TEST_CONSTEXPR_CXX20 void test_contiguous ( const C &c )
 {
     for ( size_t i = 0; i < c.size(); ++i )
         assert ( *(c.begin() + static_cast<typename C::difference_type>(i)) == *(std::addressof(*c.begin()) + i));
 }
 
-int main(int, char**)
-{
+TEST_CONSTEXPR_CXX20 bool test() {
     {
     typedef std::string S;
     test_contiguous(S());
@@ -50,6 +49,15 @@
     test_contiguous(S("1234567890123456789012345678901234567890123456789012345678901234567890", A()));
     }
 #endif
+    
+  return true;
+}
+
+int main() {
+  test();
+#if TEST_STD_VER > 17
+  static_assert(test());
+#endif
 
   return 0;
 }
diff --git a/libcxx/test/std/strings/basic.string/string.starts_with/starts_with.char.pass.cpp b/libcxx/test/std/strings/basic.string/string.starts_with/starts_with.char.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.starts_with/starts_with.char.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.starts_with/starts_with.char.pass.cpp
@@ -16,9 +16,8 @@
 
 #include "test_macros.h"
 
-int main(int, char**)
-{
-    {
+TEST_CONSTEXPR_CXX20 bool test() {
+  {
     typedef std::string S;
     S  s1 {};
     S  s2 { "abcde", 5 };
@@ -30,6 +29,15 @@
     assert ( s2.starts_with('a'));
     assert (!s2.starts_with('x'));
     }
+    
+  return true;
+}
+
+int main() {
+  test();
+#if TEST_STD_VER > 17
+  static_assert(test());
+#endif
 
   return 0;
 }
diff --git a/libcxx/test/std/strings/basic.string/string.starts_with/starts_with.ptr.pass.cpp b/libcxx/test/std/strings/basic.string/string.starts_with/starts_with.ptr.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.starts_with/starts_with.ptr.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.starts_with/starts_with.ptr.pass.cpp
@@ -16,9 +16,8 @@
 
 #include "test_macros.h"
 
-int main(int, char**)
-{
-    {
+TEST_CONSTEXPR_CXX20 bool test() {
+  {
     typedef std::string S;
     const char *s = "abcde";
     S  s0 {};
@@ -58,6 +57,15 @@
     assert (!sNot.starts_with("abcde"));
     assert ( sNot.starts_with("def"));
     }
+    
+  return true;
+}
+
+int main() {
+  test();
+#if TEST_STD_VER > 17
+  static_assert(test());
+#endif
 
   return 0;
 }
diff --git a/libcxx/test/std/strings/basic.string/string.starts_with/starts_with.string_view.pass.cpp b/libcxx/test/std/strings/basic.string/string.starts_with/starts_with.string_view.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.starts_with/starts_with.string_view.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.starts_with/starts_with.string_view.pass.cpp
@@ -16,9 +16,8 @@
 
 #include "test_macros.h"
 
-int main(int, char**)
-{
-    {
+TEST_CONSTEXPR_CXX20 bool test() {
+  {
     typedef std::string S;
     typedef std::string_view SV;
     const char *s = "abcde";
@@ -67,7 +66,16 @@
     assert (!sNot.starts_with(sv4));
     assert (!sNot.starts_with(sv5));
     assert ( sNot.starts_with(svNot));
-    }
+  }
+    
+  return true;
+}
+
+int main() {
+  test();
+#if TEST_STD_VER > 17
+  static_assert(test());
+#endif
 
   return 0;
 }
diff --git a/libcxx/test/support/iterator_traits_cpp17_iterators.h b/libcxx/test/support/iterator_traits_cpp17_iterators.h
--- a/libcxx/test/support/iterator_traits_cpp17_iterators.h
+++ b/libcxx/test/support/iterator_traits_cpp17_iterators.h
@@ -9,6 +9,7 @@
 #ifndef TEST_SUPPORT_ITERATOR_TRAITS_ITERATOR_TRAITS_CPP17_ITERATORS
 #define TEST_SUPPORT_ITERATOR_TRAITS_ITERATOR_TRAITS_CPP17_ITERATORS
 
+#include "test_macros.h"
 struct iterator_traits_cpp17_iterator {
   int& operator*();
   iterator_traits_cpp17_iterator& operator++();
@@ -27,11 +28,11 @@
   using difference_type = int;
   using value_type = long;
 
-  int& operator*();
-  iterator_traits_cpp17_input_iterator& operator++();
-  iterator_traits_cpp17_input_iterator operator++(int);
+  TEST_CONSTEXPR_CXX20 int& operator*();
+  TEST_CONSTEXPR_CXX20 iterator_traits_cpp17_input_iterator& operator++();
+  TEST_CONSTEXPR_CXX20 iterator_traits_cpp17_input_iterator operator++(int);
 
-  bool operator==(iterator_traits_cpp17_input_iterator const&) const;
+  TEST_CONSTEXPR_CXX20 bool operator==(iterator_traits_cpp17_input_iterator const&) const;
 };
 
 struct iterator_traits_cpp17_proxy_input_iterator {
diff --git a/libcxx/test/support/test_iterators.h b/libcxx/test/support/test_iterators.h
--- a/libcxx/test/support/test_iterators.h
+++ b/libcxx/test/support/test_iterators.h
@@ -457,14 +457,14 @@
 
     enum ThrowingAction { TAIncrement, TADecrement, TADereference, TAAssignment, TAComparison };
 
-    ThrowingIterator()
+    TEST_CONSTEXPR_CXX14 ThrowingIterator()
         : begin_(nullptr), end_(nullptr), current_(nullptr), action_(TADereference), index_(0) {}
-    explicit ThrowingIterator(const T *first, const T *last, int index = 0, ThrowingAction action = TADereference)
+    TEST_CONSTEXPR_CXX14 explicit ThrowingIterator(const T *first, const T *last, int index = 0, ThrowingAction action = TADereference)
         : begin_(first), end_(last), current_(first), action_(action), index_(index) {}
-    ThrowingIterator(const ThrowingIterator &rhs)
+    TEST_CONSTEXPR_CXX14 ThrowingIterator(const ThrowingIterator &rhs)
         : begin_(rhs.begin_), end_(rhs.end_), current_(rhs.current_), action_(rhs.action_), index_(rhs.index_) {}
 
-    ThrowingIterator& operator=(const ThrowingIterator& rhs) {
+    TEST_CONSTEXPR_CXX14 ThrowingIterator& operator=(const ThrowingIterator& rhs) {
         if (action_ == TAAssignment && --index_ < 0) {
 #ifndef TEST_HAS_NO_EXCEPTIONS
             throw std::runtime_error("throw from iterator assignment");
@@ -480,7 +480,7 @@
         return *this;
     }
 
-    reference operator*() const {
+    TEST_CONSTEXPR_CXX14 reference operator*() const {
         if (action_ == TADereference && --index_ < 0) {
 #ifndef TEST_HAS_NO_EXCEPTIONS
             throw std::runtime_error("throw from iterator dereference");
@@ -491,7 +491,7 @@
         return *current_;
     }
 
-    ThrowingIterator& operator++() {
+    TEST_CONSTEXPR_CXX14 ThrowingIterator& operator++() {
         if (action_ == TAIncrement && --index_ < 0) {
 #ifndef TEST_HAS_NO_EXCEPTIONS
             throw std::runtime_error("throw from iterator increment");
@@ -503,13 +503,13 @@
         return *this;
     }
 
-    ThrowingIterator operator++(int) {
+    TEST_CONSTEXPR_CXX14 ThrowingIterator operator++(int) {
         ThrowingIterator temp = *this;
         ++(*this);
         return temp;
     }
 
-    ThrowingIterator& operator--() {
+    TEST_CONSTEXPR_CXX14 ThrowingIterator& operator--() {
         if (action_ == TADecrement && --index_ < 0) {
 #ifndef TEST_HAS_NO_EXCEPTIONS
             throw std::runtime_error("throw from iterator decrement");
@@ -521,13 +521,13 @@
         return *this;
     }
 
-    ThrowingIterator operator--(int) {
+    TEST_CONSTEXPR_CXX14 ThrowingIterator operator--(int) {
         ThrowingIterator temp = *this;
         --(*this);
         return temp;
     }
 
-    friend bool operator==(const ThrowingIterator& a, const ThrowingIterator& b) {
+    TEST_CONSTEXPR_CXX14 friend bool operator==(const ThrowingIterator& a, const ThrowingIterator& b) {
         if (a.action_ == TAComparison && --a.index_ < 0) {
 #ifndef TEST_HAS_NO_EXCEPTIONS
             throw std::runtime_error("throw from iterator comparison");
@@ -542,7 +542,7 @@
         return a.current_ == b.current_;
     }
 
-    friend bool operator!=(const ThrowingIterator& a, const ThrowingIterator& b) {
+    TEST_CONSTEXPR_CXX14 friend bool operator!=(const ThrowingIterator& a, const ThrowingIterator& b) {
         return !(a == b);
     }
 
diff --git a/libcxx/test/support/test_macros.h b/libcxx/test/support/test_macros.h
--- a/libcxx/test/support/test_macros.h
+++ b/libcxx/test/support/test_macros.h
@@ -10,6 +10,8 @@
 #ifndef SUPPORT_TEST_MACROS_HPP
 #define SUPPORT_TEST_MACROS_HPP
 
+#include <version>
+
 // Attempt to get STL specific macros like _LIBCPP_VERSION using the most
 // minimal header possible. If we're testing libc++, we should use `<__config>`.
 // If <__config> isn't available, fall back to <ciso646>.
@@ -145,6 +147,12 @@
 # define TEST_THROW_SPEC(...) throw(__VA_ARGS__)
 #endif
 
+#if defined(__cpp_lib_is_constant_evaluated) && __cpp_lib_is_constant_evaluated >= 201811L
+#  define TEST_IS_CONSTANT_EVALUATED std::is_constant_evaluated()
+#else
+#  define TEST_IS_CONSTANT_EVALUATED false
+#endif
+
 #if TEST_STD_VER >= 14
 # define TEST_CONSTEXPR_CXX14 constexpr
 #else