[libc++] Implement P0980R1 (constexpr std::string)

[philnik]

• Changed split non-/constexpr tests into one and used TEST_IS_CONSTANT_EVALUATED
• replaced main() with main(int, char**)
• Updated feature-test macro

[philnik]

ping

[philnik]

Maybe @ldionne should take a look at this PR too, since it's his paper.

[philnik]

Rebased and added GCC workaround

[philnik]

Rebased

[philnik]

• Rebased
• check for nullptr

[philnik]

removed XFAIL for GCC

[philnik]

• Removed debugging stuff for constant evaluation
• fixed some tests

[philnik]

• Added check
• Using __wrap_iter now only during runtime

[ldionne]

In D110598#3135267, @philnik wrote:

Maybe @ldionne should take a look at this PR too, since it's his paper.

Will do, but I was waiting for the build to be green. Can you ping me (on Discord) when you want me to take a look?

[philnik]

• Rebased onto D114733
• Make test pass

[philnik]

• rebased
• debug iterators should work now

[philnik]

• Some formatting changes

[philnik]

ping @ldionne , @Quuxplusone

[• Quuxplusone]

Please update the PR summary (i.e. the proposed commit message and general info about the patch). Particularly, I'd like to see some paragraph-form text explaining the general approach. I'm sure it's been explained and discussed several times, e.g. on Discord, probably a couple times in this PR's comments... but IIUC the details have also changed over time. An up-to-date description belongs in the PR summary, and ultimately in the commit message. It would even be appropriate to add something to libcxx/docs/DesignDocs/. All of this will benefit the next person to maintain this and/or to implement constexpr vector or constexpr whatever-they-do-in-C++23.

It would help if this were split into relatively orthogonal chunks, most of which could be "NFC." For example:

• The test_iterators.h diff, which is just adding constexpr to one type, can be landed today AFAIC.
• The test_macros.h diff is probably unnecessary?
• A huge number of diffs in <string> are just adding the word _LIBCPP_CONSTEXPR_AFTER_CXX17; since this is all template code where the compiler shouldn't complain about incorrect constexpr keywords, can we land those as a separate patch, before the behavioral changes?
• Vice versa, can we land the behavioral changes first and then the _LIBCPP_CONSTEXPR_AFTER_CXX17 markings second?
• Several new member functions: __begin_lifetime, __finish_replace, __free_memory_constexpr, __insert_not_in_range. Can we introduce those first (changing the "shape" of the control flow), and then in a second step change their behavior to include the constexpr-friendly codepaths?
• The constexpr-ified tests do need to be landed in the same commit as the behavior they test... but for review purposes they are orthogonal/distracting.
• Even if we land this PR as a monolith, it would still be vastly easier to review in small pieces like that. If you're trying to review the control flow, all the _LIBCPP_CONSTEXPR_AFTER_CXX17 markings are distracting; and vice versa.

I don't find Phab's interface very convenient for splitting up patches in these ways. You can make a bunch of Phab PRs and link them together with dependencies, but really it might be easier to just edit the issue summary to include [the design info, plus] a link to a branch on your own GitHub (I mean a URL like https://github.com/Quuxplusone/llvm-project/compare/main...trivially-relocatable ) and say "Hey reviewers, if you prefer to see this PR broken down into its orthogonal component parts, take a look at this series of commits in GitHub."

libcxx/include/string

1807–1809

_VSTD::construct_at(_VSTD::addressof(__p[__i]), value_type())); for ADL.
On line 1785, please linebreak before void.

4220–4228

The PR summary (and possibly a design doc) should explain why the class invariants need to change in constexpr-land.
But aside from that, I find this diff hard to reason about. After some fiddling with it, I think the cleanest version introduces the concept of "SSO capacity," like this:

size_type __sso_capacity = __libcpp_is_constant_evaluated() ? 0 : (__min_cap - 1);
if (size() > capacity())
    return false;
if (capacity() < __sso_capacity)
    return false;
if (data() == nullptr)
    return false;
if (data()[size()] != value_type())
    return false;
return true;

IIUC, you use this calculation several places in this PR. Consider introducing a function __sso_capacity() for this purpose... except that at first glance I'm worried about any function whose return value changes depending on constexprness. I'm not sure that such a function is safe to use. So maybe pulling it out into a function would be very bad, I'm not sure.

[philnik]

• Rebased onto D115599

[philnik]

Rebased

[philnik]

Updates; There are still a few test changes but most are already done.

[philnik]

Poke CI

[philnik]

• generate files

[philnik]

• Fix CI

[philnik]

• Initialize union before allocating

[philnik]

• Fix alternate string layout

[philnik]

• Try to fix 32bit builds

[Mordante]

Thanks for working on this huge task!
In general I'm happy, but I'm not familiar enough with the internals of our string implementation to validate you didn't miss any important parts. Therefore I leave approval to somebody more familiar with string.

(This patch basically touches every function in string and thus "breaks" other patches for string. Would it be an idea to make some cleanup patches after this patch lands? Then we can use _LIBCPP_HIDE_FROM_ABI and std::.)

libcxx/include/string

77

Please update the synopsis.

975–976

The test test/std/strings/basic.string/string.capacity/resize_and_overwrite.pass.cpp can be updated by removing
#if defined(__cpp_lib_constexpr_string) && __cpp_lib_constexpr_string >= 201907L

1432

Nit: I would keep the order LIBCPP_INLINE_VISIBILITY constexpr for consistency with the other changes.

1482

Should these new functions be private members?

libcxx/test/std/strings/basic.string/string.access/at.pass.cpp

12

Please update the synopsis in all tests.

libcxx/test/std/strings/basic.string/string.capacity/max_size.pass.cpp

82 ↗

(On Diff #416937)

Why don't you test this in constexpr? The signature has changed in the paper.

libcxx/test/std/strings/basic.string/string.modifiers/string_insert/size_pointer_size.pass.cpp

54

Why is this part removed?

libcxx/test/std/strings/basic.string/string.starts_with/starts_with.char.pass.cpp

18–19

These functions are only available in C++20. (The same for ends_with and contains.)

[philnik]

• Update synopsis
• Address comments

[philnik]

libcxx/include/string

1432

I'd keep it as-is for now. I don't want to make this patch unnecessarily larger.

libcxx/test/std/strings/basic.string/string.capacity/max_size.pass.cpp

82 ↗

(On Diff #416937)

This test makes extremely large allocations, like numeric_limits<size_t>::max() large. Because of this the constant evaluations fails.

[philnik]

libcxx/test/std/strings/basic.string/string.modifiers/string_insert/size_pointer_size.pass.cpp

54

This is duplicated for std::string and std::basic_string<char, std::char_traits<char>, min_allocator<char>>. I just made this a template and removed the duplicated code.

[Mordante]

SGTM modulo some small issues.

libcxx/test/std/strings/basic.string/string.capacity/max_size.pass.cpp

82 ↗

(On Diff #416937)

Then please a test to validate the function can be called compile-time and add comment why we done the minimal testing for compile-time testing.

libcxx/test/std/strings/basic.string/string.contains/contains.char.pass.cpp

18–19

[philnik]

• Address comments

[ldionne]

Thanks for the patch! Mostly small comments about forgetting stuff in the tests, however I think we'll need to figure out a better story for the string's invariant inside constexpr. I think we agreed on a direction to investigate during our live review, so let's try that and re-evaluate after. Thanks!

cross-project-tests/debuginfo-tests/llvm-prettyprinters/gdb/mlir-support.cpp

12

I don't think you intended to upload that.

libcxx/include/string

900–906

Please consider not reformatting as part of this patch since it's good to keep it as mechanical as possible.

1937–1938

What if instead of doing this, we made sure to have the invariants of the string hold before calling __init, and then we'd "simply" have to check whether we already have a long string allocated at the beginning of __init?

2090

This line does not look correct to me. Indeed, if __str is a short string, after the change we are accessing __str's long representation instead of its raw representation, which means that we might not be copying some part of the small buffer, if the small buffer is larger than the long representation.

This could happen if we had a very large character type where 2 * sizeof(CharType) is larger than sizeof(LongRepresentation). In that case, our short string buffer will contain two CharTypes at least, yet our long representation will be smaller than that. Please add a test to catch this, or explain why that doesn't work (you mentioned a bug related to large character types during live review).

2378–2382

Why don't we call __default_init() on a moved-from string instead?

Right now, after calling __zero() during constexpr evaluation, the string is invalid to access, thus we don't have the invariant __is_long(). Instead, I think we should make sure that the string satisfies __is_long() at all times during constexpr evaluation, which probably means replacing a few calls to __zero() by calls to __default_init().

This would allow removing the diff above.

2587

Same here -- if the invariant __is_long() held during constexpr evaluation, this nullptr check could go away.

2602

For instance, I think this is one place where we should call __default_init() instead.

2911–2917

I'd like to understand why this diff is needed. What happens if you remove it?

3179–3182

Same question here -- why is this required?

4222–4223

If we never put the string in an invalid state inside constexpr, is it possible to remove this diff entirely?

4464–4465

Could we investigate adding a private constructor that allows passing a capacity to pre-allocate, so this could be implemented like this:

using _String = basic_string<_CharT, _Traits, _Allocator>;
typename _String::size_type __lhs_sz = __lhs.size();
typename _String::size_type __rhs_sz = __rhs.size();
_String __r(_String::__alloc_traits::select_on_container_copy_construction(__lhs.get_allocator()), __capacity_tag{}, __lhs_sz + __rhs_sz);
__r.append(__lhs.data(), __lhs_sz);
__r.append(__rhs.data(), __rhs_sz);
return __r;

Can we please do this as a separate review? That should be easy to split out.

libcxx/test/std/strings/basic.string/string.cons/default_noexcept.pass.cpp

26–37 ↗

(On Diff #419393)

Unless I am mistaken, we don't seem to have any test for basic_string::basic_string() that runs at runtime. This is kind of crazy.

As a different review, can you please move this test to default.pass.cpp, make it run the default constructor at runtime, and prepare it for constexpr-friendliness as well? That way, this diff can look like the other ones where you basically uncomment static_assert(test());.

libcxx/test/std/strings/basic.string/string.cons/dtor_noexcept.pass.cpp

13 ↗

(On Diff #419393)

Same thing here -- we don't have a runtime test for the string destructor outside of the static variable below. Please add one -- this can be done in the same review as the default ctor.

You could use a special allocator and check that deallocate() has been called after the string is destroyed.

libcxx/test/std/strings/basic.string/string.iterators/iterators.pass.cpp

65–75

I think this needs to change to TEST_STD_VER > 17?

Please also grep for __cpp_lib_constexpr_string after applying your patch just to make sure there aren't any stray ones left where they shouldn't be.

libcxx/test/std/strings/basic.string/string.modifiers/string_insert/size_T_size_size.pass.cpp

1867–1898 ↗

(On Diff #419393)

I think you missed those.

I'm also not a big fan of the 2k lines of test here, but this has nothing to do with this review.

libcxx/test/std/strings/basic.string/string.modifiers/string_insert/size_string_size_size.pass.cpp

1787–1790

You forgot those too! Please grep for // static_assert in the test suite just to make sure you haven't missed other ones.

libcxx/test/std/strings/basic.string/string.modifiers/string_replace/iter_iter_iter_iter.pass.cpp

1072–1073

Here!

libcxx/test/std/strings/basic.string/string.modifiers/string_replace/iter_iter_pointer_size.pass.cpp

943–944

Here!

libcxx/test/std/strings/basic.string/string.modifiers/string_replace/size_size_T_size_size.pass.cpp

6079 ↗

(On Diff #419393)

Here!

libcxx/test/std/strings/basic.string/string.modifiers/string_replace/size_size_pointer_size.pass.cpp

1340 ↗

(On Diff #419393)

Here!

libcxx/test/std/strings/basic.string/string.modifiers/string_replace/size_size_string_size_size.pass.cpp

6069 ↗

(On Diff #419393)

Here!

Wow, 6k lines of test. I'm sure they are all 100% relevant -_-.

libcxx/test/std/strings/basic.string/string.nonmembers/string.io/get_line.pass.cpp

14 ↗

(On Diff #419393)

I don't think you meant to make this one constexpr.

libcxx/test/std/strings/basic.string/string.nonmembers/string.io/get_line_delim.pass.cpp

14 ↗

(On Diff #419393)

Same, not constexpr.

libcxx/test/std/strings/basic.string/string.nonmembers/string.io/get_line_delim_rv.pass.cpp

14 ↗

(On Diff #419393)

Same!

libcxx/test/std/strings/basic.string/string.nonmembers/string.io/get_line_rv.pass.cpp

14 ↗

(On Diff #419393)

Same, and for all string.io probably.

libcxx/test/std/strings/basic.string/string.ops/string_compare/size_size_T_size_size.pass.cpp

5842–5843

We are missing some constexpr-ification here for sure.

libcxx/test/std/strings/basic.string/string.ops/string_compare/size_size_pointer_size.pass.cpp

1294–1295

Missed these ones!

libcxx/test/std/strings/basic.string/string.ops/string_compare/size_size_string_size_size.pass.cpp

5946–5949

Missed!

libcxx/test/std/strings/basic.string/string.ops/string_find.last.not.of/string_view_size.pass.cpp

154–157

Can you try uncommenting this and seeing what happens?

libcxx/test/support/constexpr_char_traits.h

121 ↗

(On Diff #419393)

// fails in constexpr because we might be comparing unrelated pointers

[philnik]

• Rebased
• Address comments

libcxx/include/string

1937–1938

I think we agreed that this is OK and we make sure that __init is only ever called inside constructors.

2911–2917

We may compare unrelated pointers with __p + __pos <= __s && __s < __p + __sz.

3179–3182

Same here - we may compare unrelated pointers.

4464–4465

This is D123058 now.

libcxx/test/std/strings/basic.string/string.cons/dtor_noexcept.pass.cpp

13 ↗

(On Diff #419393)

This is now D123129.

libcxx/test/std/strings/basic.string/string.ops/string_find.last.not.of/string_view_size.pass.cpp

154–157

Seems to just work.

[philnik]

• Fix CI

[ldionne]

Thanks! Still a few comments and questions, but this is looking really good now.

libcxx/include/string

1553–1554

I don't understand why this diff is required when running in constexpr. What happens if you remove it?

1580

Is there any reason why we don't simply always do __r_.first() = __rep()? That would work both in constexpr and non-constexpr, and it seems to be pretty much equivalent: https://godbolt.org/z/T85f13ozT

And when that's done, perhaps we can even remove __zero() altogether?

1764–1765

This needs a comment!

3179–3181

Note to future me: I looked at this and it seems OK, no need to spend another 15 minutes validating.

3530

Can we repace this by a call to __fits_in_sso(__target_capacity)? (or maybe __target_capacity +/- 1, please double-check)

libcxx/test/support/constexpr_char_traits.h

130 ↗

(On Diff #421756)

@daltenty The CI is currently failing in pretty bad ways on AIX. The compiler is being reported as IBM Open XL C/C++ for AIX 17.1.0 (5725-C72, 5765-J18), clang version 13.0.0, which we claim to support on our page.

I believe there might be some patches to the constant evaluator on top of Clang 13 that have not been cherry-picked to your internal branch. I suspect there are probably no reasonable workarounds to make std::string work inside constexpr on that compiler without fixing the compiler itself. Hence, I am unsure what's the best course of action here. I think what we should do is either:

1. Mark those tests as XFAIL temporarily on AIX (LIBCXX-AIX-FIXME). This has the downside that you'll lose coverage for std::string at runtime too. Otherwise,
2. Introduce a macro and #ifdef out only the constexpr part of the tests on AIX until the compiler is fixed or updated. I'm fine with doing that, but only if we know that it's a temporary state (< 6 months roughly).

Do you have thoughts on that?

Note to @philnik: Since I'm about to go OOO, if there is no resolution for this by EOW, feel free to land this with option (1) above (which is simplest) and we can always do (2) afterwards if that's the preferred solution.

[philnik]

• Rebased onto D123580
• Address comments

libcxx/include/string

1553–1554

Fixed the bug!

[philnik]

Rebased

[philnik]

Rebased

[ldionne]

libcxx/include/string

1601–1603

Can you explain this?

[philnik]

libcxx/include/string

1601–1603

During runtime we never actually allocate __min_cap bytes, so it's OK that we return an even number in this case. It only exists for checking if the string fits in SSO or is in SSO mode AFAICT. (This should probably be changed at some point) During constant evaluation we have to return an odd number to make the allocation size even, otherwise we save garbage in the capacity member. That's why the other way to fix the bug was saving the actual capacity.

[ldionne]

Please rebase onto main to get a clean CI run, and ship it. Thanks!

libcxx/include/string

1601–1603

Ok. As discussed offline, let's land this as-is, but let's also make a follow-up patch that tries to fix places that assume __min_cap - 1 is returned when the string fits in the SSO, so we can remove this if and always return static_cast<size_type>(__min_cap);.

[philnik]

• Rebased
• XFAIL AIX

[philnik]

• Add a few more XFAILs

cross-project-tests/debuginfo-tests/llvm-prettyprinters/gdb/mlir-support.cpp

 #include "mlir/IR/BuiltinAttributes.h"
 #include "mlir/IR/BuiltinTypes.h"
 #include "mlir/IR/Identifier.h"
 #include "mlir/IR/Location.h"
 #include "mlir/IR/MLIRContext.h"
 #include "mlir/IR/OperationSupport.h"
 
 mlir::MLIRContext Context;
 
 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 =
     mlir::IntegerType::get(&Context, 3, mlir::IntegerType::Unsigned);
 mlir::Type FloatType = mlir::Float32Type::get(&Context);
 mlir::Type MemRefType = mlir::MemRefType::get({4, 5}, FloatType);
 mlir::Type UnrankedMemRefType = mlir::UnrankedMemRefType::get(IntegerType, 6);
 mlir::Type VectorType = mlir::VectorType::get({1, 2}, FloatType);

libcxx/include/__string

for (; __n; --__n, ++__s)
         assign(*__s, __a);
     return __r;
 }
 
 // constexpr versions of move/copy/assign.
 
 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;
 }
 
 template <class _CharT>
 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;
 }
 
 // char_traits<char>
 
 template <>
 struct _LIBCPP_TEMPLATE_VIS char_traits<char>
 {
     typedef char      char_type;
     typedef int       int_type;
     typedef streamoff off_type;
     typedef streampos pos_type;
     typedef mbstate_t state_type;
 
     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;}
     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
     char_type* move(char_type* __s1, const char_type* __s2, size_t __n) _NOEXCEPT
         {
             return __libcpp_is_constant_evaluated()
                        ? _VSTD::__move_constexpr(__s1, __s2, __n)
                        : __n == 0 ? __s1 : (char_type*)_VSTD::memmove(__s1, __s2, __n);

libcxx/include/string

 
 template <> struct char_traits<char>;
 template <> struct char_traits<wchar_t>;
 template <> struct char_traits<char8_t>;  // C++20
 template <> struct char_traits<char16_t>;
 template <> struct char_traits<char32_t>;
 
 template<class charT, class traits = char_traits<charT>, class Allocator = allocator<charT> >
 class basic_string
 {
 public:
 // types:
     typedef traits traits_type;
     typedef typename traits_type::char_type value_type;
     typedef Allocator allocator_type;
     typedef typename allocator_type::size_type size_type;
     typedef typename allocator_type::difference_type difference_type;

 }  // std
 
 */
 
 #include <__config>
 #include <__debug>
 #include <__functional_base>
 #include <__iterator/wrap_iter.h>
+#include <__memory/construct_at.h>
 #include <algorithm>
 #include <compare>
 #include <cstdio>  // EOF
 #include <cstdlib>
 #include <cstring>
 #include <initializer_list>
 #include <iosfwd>
 #include <iterator>

 
 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);
 
 _LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS string operator+<char, char_traits<char>, allocator<char> >(char const*, string const&))
 
 template <bool>
 struct __basic_string_common;
 
 template <>
 struct __basic_string_common<true> {
     // Both are defined in string.cpp
     _LIBCPP_NORETURN _LIBCPP_EXPORTED_FROM_ABI void __throw_length_error() const;
     _LIBCPP_NORETURN _LIBCPP_EXPORTED_FROM_ABI void __throw_out_of_range() const;
 };
 
#endif
     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_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));
-#   if _LIBCPP_DEBUG_LEVEL == 2
+#if _LIBCPP_DEBUG_LEVEL == 2
+    if (!__libcpp_is_constant_evaluated())
       __get_db()->__insert_c(this);
-#   endif
+#endif
     }
 
     template <class = __enable_if_t<__is_allocator<_Allocator>::value, nullptr_t> >
         _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_CXX03_LANG
 
     inline _LIBCPP_CONSTEXPR_AFTER_CXX17 ~basic_string();
 
     _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_CONSTEXPR_AFTER_CXX17
     basic_string& operator=(basic_string&& __str)
         _NOEXCEPT_((__noexcept_move_assign_container<_Allocator, __alloc_traits>::value));
      _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 _LIBCPP_CONSTEXPR_AFTER_CXX17
#endif // _LIBCPP_DEBUG_LEVEL == 2
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     const_reverse_iterator crbegin() const _NOEXCEPT
         {return rbegin();}
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     const_reverse_iterator crend() const _NOEXCEPT
         {return rend();}
 
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 size_type size() const _NOEXCEPT
         {return __is_long() ? __get_long_size() : __get_short_size();}
     _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()); }
 
#endif // _LIBCPP_CXX03_LANG
     _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_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_CONSTEXPR_AFTER_CXX17
     basic_string& assign(const basic_string& __str) { return *this = __str; }
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
             int
         >
         compare(size_type __pos1, size_type __n1, const _Tp& __t, size_type __pos2, size_type __n2=npos) 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
     constexpr _LIBCPP_INLINE_VISIBILITY
     bool starts_with(__self_view __sv) const noexcept
     { return __self_view(data(), size()).starts_with(__sv); }
 
     constexpr _LIBCPP_INLINE_VISIBILITY
     bool starts_with(value_type __c) const noexcept
     { return !empty() && _Traits::eq(front(), __c); }
 
     constexpr _LIBCPP_INLINE_VISIBILITY
#if _LIBCPP_STD_VER > 20
 
     constexpr _LIBCPP_INLINE_VISIBILITY
     bool contains(const value_type* __s) const
     { return __self_view(data(), size()).contains(__s); }
 #endif
 
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 bool __invariants() const;
 
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 void __clear_and_shrink() _NOEXCEPT;
 
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 void __shrink_or_extend(size_type __target_capacity);
 
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 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;
     }
 
 #if _LIBCPP_DEBUG_LEVEL == 2
 
     bool __dereferenceable(const const_iterator* __i) const;
     bool __decrementable(const const_iterator* __i) const;
     bool __addable(const const_iterator* __i, ptrdiff_t __n) const;
     bool __subscriptable(const const_iterator* __i, ptrdiff_t __n) const;
 
 #endif // _LIBCPP_DEBUG_LEVEL == 2
#endif // _LIBCPP_ABI_ALTERNATE_STRING_LAYOUT
     void __set_size(size_type __s) _NOEXCEPT
         {if (__is_long()) __set_long_size(__s); else __set_short_size(__s);}
 
     _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_CONSTEXPR_AFTER_CXX17
     size_type __get_long_cap() const _NOEXCEPT
         {return __r_.first().__l.__cap_ & size_type(~__long_mask);}
 
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     void __set_long_pointer(pointer __p) _NOEXCEPT
         {__r_.first().__l.__data_ = __p;}
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     pointer __get_long_pointer() _NOEXCEPT
         {return __r_.first().__l.__data_;}
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     const_pointer __get_long_pointer() const _NOEXCEPT
         {return __r_.first().__l.__data_;}
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     pointer __get_short_pointer() _NOEXCEPT
         {return pointer_traits<pointer>::pointer_to(__r_.first().__s.__data_[0]);}
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     const_pointer __get_short_pointer() const _NOEXCEPT
         {return pointer_traits<const_pointer>::pointer_to(__r_.first().__s.__data_[0]);}
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     pointer __get_pointer() _NOEXCEPT
         {return __is_long() ? __get_long_pointer() : __get_short_pointer();}
     _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 _LIBCPP_CONSTEXPR_AFTER_CXX17
-    void __zero() _NOEXCEPT
-        {
-            size_type (&__a)[__n_words] = __r_.first().__r.__words;
-            for (unsigned __i = 0; __i < __n_words; ++__i)
-                __a[__i] = 0;
-        }
+    void __zero() _NOEXCEPT {
+      if (__libcpp_is_constant_evaluated()) {
+        __r_.first() = __rep();
+        return;
+      }
 
     template <size_type __a> static
         _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 _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 _LIBCPP_CONSTEXPR_AFTER_CXX17
     void __init(const value_type* __s, size_type __sz, size_type __reserve);
     inline _LIBCPP_CONSTEXPR_AFTER_CXX17
-    void __init(const value_type* __s, size_type __sz);
+    void __init(const value_type* __s, size_type __sz)  { __init(__s, __sz, __sz); }
     inline _LIBCPP_CONSTEXPR_AFTER_CXX17
     void __init(size_type __n, value_type __c);
 
     // Slow path for the (inlined) copy constructor for 'long' strings.
     // Always externally instantiated and not inlined.
     // Requires that __s is zero terminated.
     // The main reason for this function to exist is because for unstable, we
     // want to allow inlining of the copy constructor. However, we don't want
#endif // _LIBCPP_ABI_ALTERNATE_STRING_LAYOUT
     template <class _ForwardIterator>
     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() {
+      if (__libcpp_is_constant_evaluated() && __get_long_pointer() != nullptr) {
+        __alloc_traits::deallocate(__alloc(), __get_long_pointer(), __get_long_cap());
+        __zero();
+      }
+    }
+
     _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);
 
     // __assign_no_alias is invoked for assignment operations where we
     // 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_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.
     _LIBCPP_CONSTEXPR_AFTER_CXX17 void __erase_external_with_move(size_type __pos, size_type __n);
 
     _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>());}
void __copy_assign_alloc(const basic_string& __str, true_type)
                 {
                     __clear_and_shrink();
                     __alloc() = __str.__alloc();
                 }
                 else
                 {
                     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);
                     __set_long_cap(__str.__get_long_cap());
                     __set_long_size(__str.size());
                 }
             }
         }
#endif
     }
 
     _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
     bool __addr_in_range(_Tp&& __t) const {
         const volatile void *__p = _VSTD::addressof(__t);
         return data() <= __p && __p <= data() + size();
     }
 
     _LIBCPP_NORETURN _LIBCPP_HIDE_FROM_ABI
     void __throw_length_error() const {
 #ifndef _LIBCPP_NO_EXCEPTIONS
         __basic_string_common<true>::__throw_length_error();
 #else
         _VSTD::abort();
 #endif
     }
 
     _LIBCPP_NORETURN _LIBCPP_HIDE_FROM_ABI
     void __throw_out_of_range() const {
 #ifndef _LIBCPP_NO_EXCEPTIONS
         __basic_string_common<true>::__throw_out_of_range();
 #else
         _VSTD::abort();
 #endif
     }
 
+  _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
 // so that they have the correct visibility specifier.
 #ifdef _LIBCPP_ABI_STRING_OPTIMIZED_EXTERNAL_INSTANTIATION
     _LIBCPP_STRING_UNSTABLE_EXTERN_TEMPLATE_LIST(_LIBCPP_EXTERN_TEMPLATE, char)
 #   ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
         _LIBCPP_STRING_UNSTABLE_EXTERN_TEMPLATE_LIST(_LIBCPP_EXTERN_TEMPLATE, wchar_t)
 #   endif
 #else

 #endif
 
 template <class _CharT, class _Traits, class _Allocator>
 inline _LIBCPP_CONSTEXPR_AFTER_CXX17
 void
 basic_string<_CharT, _Traits, _Allocator>::__invalidate_all_iterators()
 {
 #if _LIBCPP_DEBUG_LEVEL == 2
+  if (!__libcpp_is_constant_evaluated())
     __get_db()->__invalidate_all(this);
 #endif
 }
 
 template <class _CharT, class _Traits, class _Allocator>
 inline _LIBCPP_CONSTEXPR_AFTER_CXX17
 void
 basic_string<_CharT, _Traits, _Allocator>::__invalidate_iterators_past(size_type __pos)
 {
 #if _LIBCPP_DEBUG_LEVEL == 2
+  if (!__libcpp_is_constant_evaluated()) {
     __c_node* __c = __get_db()->__find_c_and_lock(this);
     if (__c)
     {
         const_pointer __new_last = __get_pointer() + __pos;
         for (__i_node** __p = __c->end_; __p != __c->beg_; )
         {
             --__p;
             const_iterator* __i = static_cast<const_iterator*>((*__p)->__i_);
             if (__i->base() > __new_last)
             {
                 (*__p)->__c_ = nullptr;
                 if (--__c->end_ != __p)
                     _VSTD::memmove(__p, __p+1, (__c->end_ - __p)*sizeof(__i_node*));
             }
         }
         __get_db()->unlock();
     }
+  }
 #else
     (void)__pos;
 #endif // _LIBCPP_DEBUG_LEVEL == 2
 }
 
 template <class _CharT, class _Traits, class _Allocator>
 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())
 {
 #if _LIBCPP_DEBUG_LEVEL == 2
+  if (!__libcpp_is_constant_evaluated())
     __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 _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)
 #else
         _NOEXCEPT
 #endif
 : __r_(__default_init_tag(), __a)
 {
 #if _LIBCPP_DEBUG_LEVEL == 2
+  if (!__libcpp_is_constant_evaluated())
     __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>
 _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();
     }
     else
     {
         size_type __cap = __recommend(__reserve);
         __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());
-}
-
-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);
+        __begin_lifetime(__p, __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());
 }
 
 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)
 {
     _LIBCPP_ASSERT(__s != nullptr, "basic_string(const char*, allocator) detected nullptr");
     __init(__s, traits_type::length(__s));
 #if _LIBCPP_DEBUG_LEVEL == 2
+  if (!__libcpp_is_constant_evaluated())
     __get_db()->__insert_c(this);
 #endif
 }
 
 template <class _CharT, class _Traits, class _Allocator>
 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())
 {
     _LIBCPP_ASSERT(__n == 0 || __s != nullptr, "basic_string(const char*, n) detected nullptr");
     __init(__s, __n);
 #if _LIBCPP_DEBUG_LEVEL == 2
+  if (!__libcpp_is_constant_evaluated())
     __get_db()->__insert_c(this);
 #endif
 }
 
 template <class _CharT, class _Traits, class _Allocator>
 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)
 {
     _LIBCPP_ASSERT(__n == 0 || __s != nullptr, "basic_string(const char*, n, allocator) detected nullptr");
     __init(__s, __n);
 #if _LIBCPP_DEBUG_LEVEL == 2
+  if (!__libcpp_is_constant_evaluated())
     __get_db()->__insert_c(this);
 #endif
 }
 
 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()))
 {
     if (!__str.__is_long())
         __r_.first().__r = __str.__r_.first().__r;
     else
         __init_copy_ctor_external(_VSTD::__to_address(__str.__get_long_pointer()),
                                   __str.__get_long_size());
 
 #if _LIBCPP_DEBUG_LEVEL == 2
+  if (!__libcpp_is_constant_evaluated())
     __get_db()->__insert_c(this);
 #endif
 }
 
 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)
 {
     if (!__str.__is_long())
         __r_.first().__r = __str.__r_.first().__r;
     else
         __init_copy_ctor_external(_VSTD::__to_address(__str.__get_long_pointer()),
                                   __str.__get_long_size());
 #if _LIBCPP_DEBUG_LEVEL == 2
+  if (!__libcpp_is_constant_evaluated())
     __get_db()->__insert_c(this);
 #endif
 }
 
 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 {
     if (__sz > max_size())
       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);
   }
   traits_type::copy(_VSTD::__to_address(__p), __s, __sz + 1);
 }
 
 #ifndef _LIBCPP_CXX03_LANG
 
 template <class _CharT, class _Traits, class _Allocator>
 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)
 #else
         _NOEXCEPT
 #endif
     : __r_(_VSTD::move(__str.__r_))
 {
     __str.__zero();
 #if _LIBCPP_DEBUG_LEVEL == 2
+  if (!__libcpp_is_constant_evaluated()) {
     __get_db()->__insert_c(this);
     if (__is_long())
         __get_db()->swap(this, &__str);
+  }
 #endif
 }
 
 template <class _CharT, class _Traits, class _Allocator>
 inline _LIBCPP_CONSTEXPR_AFTER_CXX17
 basic_string<_CharT, _Traits, _Allocator>::basic_string(basic_string&& __str, const allocator_type& __a)
     : __r_(__default_init_tag(), __a)
 {
     if (__str.__is_long() && __a != __str.__alloc()) // copy, not move
         __init(_VSTD::__to_address(__str.__get_long_pointer()), __str.__get_long_size());
     else
     {
+        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
+  if (!__libcpp_is_constant_evaluated()) {
     __get_db()->__insert_c(this);
     if (__is_long())
         __get_db()->swap(this, &__str);
+  }
 #endif
 }
 
 #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();
     }
     else
     {
         size_type __cap = __recommend(__n);
-        __p = __alloc_traits::allocate(__alloc(), __cap+1);
+        __p = __alloc_traits::allocate(__alloc(), __cap + 1);
+        __begin_lifetime(__p, __cap + 1);
         __set_long_pointer(__p);
-        __set_long_cap(__cap+1);
+        __set_long_cap(__cap + 1);
         __set_long_size(__n);
     }
     traits_type::assign(_VSTD::__to_address(__p), __n, __c);
     traits_type::assign(__p[__n], value_type());
 }
 
 template <class _CharT, class _Traits, class _Allocator>
 inline _LIBCPP_CONSTEXPR_AFTER_CXX17
 basic_string<_CharT, _Traits, _Allocator>::basic_string(size_type __n, _CharT __c)
      : __r_(__default_init_tag(), __default_init_tag())
 {
     __init(__n, __c);
 #if _LIBCPP_DEBUG_LEVEL == 2
+  if (!__libcpp_is_constant_evaluated())
     __get_db()->__insert_c(this);
 #endif
 }
 
 template <class _CharT, class _Traits, class _Allocator>
 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)
 {
     __init(__n, __c);
 #if _LIBCPP_DEBUG_LEVEL == 2
+  if (!__libcpp_is_constant_evaluated())
     __get_db()->__insert_c(this);
 #endif
 }
 
 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)
     : __r_(__default_init_tag(), __a)
 {
     size_type __str_sz = __str.size();
     if (__pos > __str_sz)
         this->__throw_out_of_range();
     __init(__str.data() + __pos, _VSTD::min(__n, __str_sz - __pos));
 #if _LIBCPP_DEBUG_LEVEL == 2
+  if (!__libcpp_is_constant_evaluated())
     __get_db()->__insert_c(this);
 #endif
 }
 
 template <class _CharT, class _Traits, class _Allocator>
 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)
 {
     size_type __str_sz = __str.size();
     if (__pos > __str_sz)
         this->__throw_out_of_range();
     __init(__str.data() + __pos, __str_sz - __pos);
 #if _LIBCPP_DEBUG_LEVEL == 2
+  if (!__libcpp_is_constant_evaluated())
     __get_db()->__insert_c(this);
 #endif
 }
 
 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)
 {
     __self_view __sv0 = __t;
     __self_view __sv = __sv0.substr(__pos, __n);
     __init(__sv.data(), __sv.size());
 #if _LIBCPP_DEBUG_LEVEL == 2
+  if (!__libcpp_is_constant_evaluated())
     __get_db()->__insert_c(this);
 #endif
 }
 
 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())
 {
     __self_view __sv = __t;
     __init(__sv.data(), __sv.size());
 #if _LIBCPP_DEBUG_LEVEL == 2
+  if (!__libcpp_is_constant_evaluated())
     __get_db()->__insert_c(this);
 #endif
 }
 
 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)
 {
     __self_view __sv = __t;
     __init(__sv.data(), __sv.size());
 #if _LIBCPP_DEBUG_LEVEL == 2
+  if (!__libcpp_is_constant_evaluated())
     __get_db()->__insert_c(this);
 #endif
 }
 
 template <class _CharT, class _Traits, class _Allocator>
 template <class _InputIterator>
 _LIBCPP_CONSTEXPR_AFTER_CXX17
 __enable_if_t
 <
     __is_exactly_cpp17_input_iterator<_InputIterator>::value
 >
 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
     {
 #endif // _LIBCPP_NO_EXCEPTIONS
     for (; __first != __last; ++__first)
         push_back(*__first);
 #ifndef _LIBCPP_NO_EXCEPTIONS
     }

 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();
     }
     else
     {
         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);
     }
 
 #ifndef _LIBCPP_NO_EXCEPTIONS
     try
     {

 template <class _CharT, class _Traits, class _Allocator>
 template<class _InputIterator, class>
 inline _LIBCPP_CONSTEXPR_AFTER_CXX17
 basic_string<_CharT, _Traits, _Allocator>::basic_string(_InputIterator __first, _InputIterator __last)
      : __r_(__default_init_tag(), __default_init_tag())
 {
     __init(__first, __last);
 #if _LIBCPP_DEBUG_LEVEL == 2
+  if (!__libcpp_is_constant_evaluated())
     __get_db()->__insert_c(this);
 #endif
 }
 
 template <class _CharT, class _Traits, class _Allocator>
 template<class _InputIterator, class>
 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)
 {
     __init(__first, __last);
 #if _LIBCPP_DEBUG_LEVEL == 2
+  if (!__libcpp_is_constant_evaluated())
     __get_db()->__insert_c(this);
 #endif
 }
 
 #ifndef _LIBCPP_CXX03_LANG
 
 template <class _CharT, class _Traits, class _Allocator>
 inline _LIBCPP_CONSTEXPR_AFTER_CXX17
 basic_string<_CharT, _Traits, _Allocator>::basic_string(
     initializer_list<_CharT> __il)
      : __r_(__default_init_tag(), __default_init_tag())
 {
     __init(__il.begin(), __il.end());
 #if _LIBCPP_DEBUG_LEVEL == 2
+  if (!__libcpp_is_constant_evaluated())
     __get_db()->__insert_c(this);
 #endif
 }
 
 template <class _CharT, class _Traits, class _Allocator>
 inline _LIBCPP_CONSTEXPR_AFTER_CXX17
 basic_string<_CharT, _Traits, _Allocator>::basic_string(
     initializer_list<_CharT> __il, const _Allocator& __a)
     : __r_(__default_init_tag(), __a)
 {
     __init(__il.begin(), __il.end());
 #if _LIBCPP_DEBUG_LEVEL == 2
+  if (!__libcpp_is_constant_evaluated())
     __get_db()->__insert_c(this);
 #endif
 }
 
 #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
+  if (!__libcpp_is_constant_evaluated())
     __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())
 }
 
 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),
                           _VSTD::__to_address(__old_p), __n_copy);
     if (__n_add != 0)
         traits_type::copy(_VSTD::__to_address(__p) + __n_copy, __p_new_stuff, __n_add);
     size_type __sec_cp_sz = __old_sz - __n_del - __n_copy;
     if (__sec_cp_sz != 0)
         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);
     __old_sz = __n_copy + __n_add + __sec_cp_sz;
     __set_long_size(__old_sz);
     traits_type::assign(__p[__old_sz], value_type());
 }
 
 template <class _CharT, class _Traits, class _Allocator>
-void
 _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)
 {
     size_type __ms = max_size();
     if (__delta_cap > __ms - __old_cap)
         this->__throw_length_error();
     pointer __old_p = __get_pointer();
     size_type __cap = __old_cap < __ms / 2 - __alignment ?
                           __recommend(_VSTD::max(__old_cap + __delta_cap, 2 * __old_cap)) :
                           __ms - 1;
-    pointer __p = __alloc_traits::allocate(__alloc(), __cap+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),
                           _VSTD::__to_address(__old_p), __n_copy);
     size_type __sec_cp_sz = __old_sz - __n_del - __n_copy;
     if (__sec_cp_sz != 0)
         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)
-        __alloc_traits::deallocate(__alloc(), __old_p, __old_cap+1);
+    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);
+    __set_long_cap(__cap + 1);
 }
 
 // assign
 
 template <class _CharT, class _Traits, class _Allocator>
 template <bool __is_short>
 _LIBCPP_CONSTEXPR_AFTER_CXX17
 basic_string<_CharT, _Traits, _Allocator>&

 }
 
 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)

 void
 basic_string<_CharT, _Traits, _Allocator>::__move_assign(basic_string& __str, true_type)
 #if _LIBCPP_STD_VER > 14
     _NOEXCEPT
 #else
     _NOEXCEPT_(is_nothrow_move_assignable<allocator_type>::value)
 #endif
 {
+  if (__libcpp_is_constant_evaluated()) {
+    _VSTD::swap(__r_.first(), __str.__r_.first());
+    return;
+  }
+
   if (__is_long()) {
     __alloc_traits::deallocate(__alloc(), __get_long_pointer(),
                                __get_long_cap());
 #if _LIBCPP_STD_VER <= 14
     if (!is_nothrow_move_assignable<allocator_type>::value) {
       __set_short_size(0);
       traits_type::assign(__get_short_pointer()[0], value_type());
     }
 #endif
   }
   __move_assign_alloc(__str);
+
   __r_.first() = __str.__r_.first();
   __str.__set_short_size(0);
   traits_type::assign(__str.__get_short_pointer()[0], value_type());
 }
 
 template <class _CharT, class _Traits, class _Allocator>
 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))
 {
     __move_assign(__str, integral_constant<bool,
<
     basic_string<_CharT, _Traits, _Allocator>&
 >
 basic_string<_CharT, _Traits, _Allocator>::assign(_ForwardIterator __first, _ForwardIterator __last)
 {
     size_type __cap = capacity();
     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)
         {
             size_type __sz = size();
             __grow_by(__cap, __n - __cap, __sz, 0, __sz);
         }
         pointer __p = __get_pointer();

 
 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);
 }
 // append
 
 template <class _CharT, class _Traits, class _Allocator>
 _LIBCPP_CONSTEXPR_AFTER_CXX17

 basic_string<_CharT, _Traits, _Allocator>::append(
     _ForwardIterator __first, _ForwardIterator __last)
 {
     size_type __sz = size();
     size_type __cap = capacity();
     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)
                 __grow_by(__cap, __sz + __n - __cap, __sz, __sz, 0);
             pointer __p = __get_pointer() + __sz;
             for (; __first != __last; ++__p, (void) ++__first)
                 traits_type::assign(*__p, *__first);
             traits_type::assign(*__p, value_type());
basic_string<_CharT, _Traits, _Allocator>::append(const value_type* __s)
     return append(__s, traits_type::length(__s));
 }
 
 // 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)
-        {
-            value_type* __p = _VSTD::__to_address(__get_pointer());
-            size_type __n_move = __sz - __pos;
+        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* __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);
-            }
-            traits_type::move(__p + __pos, __s, __n);
-            __sz += __n;
-            __set_size(__sz);
-            traits_type::assign(__p[__sz], value_type());
+                if (__begin + __pos <= __s && __s < __begin + __size)
+                    __s += __count;
+                traits_type::move(__begin + __pos + __count, __begin + __pos, __n_move);
+            }
+            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)
 {

 __enable_if_t
 <
    __is_exactly_cpp17_input_iterator<_InputIterator>::value,
    typename basic_string<_CharT, _Traits, _Allocator>::iterator
 >
 basic_string<_CharT, _Traits, _Allocator>::insert(const_iterator __pos, _InputIterator __first, _InputIterator __last)
 {
 #if _LIBCPP_DEBUG_LEVEL == 2
+  if (!__libcpp_is_constant_evaluated())
     _LIBCPP_ASSERT(__get_const_db()->__find_c_from_i(&__pos) == this,
         "string::insert(iterator, range) called with an iterator not"
         " referring to this string");
 #endif
     const basic_string __temp(__first, __last, __alloc());
     return insert(__pos, __temp.data(), __temp.data() + __temp.size());
 }
 
-template <class _CharT, class _Traits, class _Allocator>
+template<class _CharT, class _Traits, class _Allocator>
 template<class _ForwardIterator>
-_LIBCPP_CONSTEXPR_AFTER_CXX17
-__enable_if_t
-<
-    __is_cpp17_forward_iterator<_ForwardIterator>::value,
-    typename basic_string<_CharT, _Traits, _Allocator>::iterator
->
-basic_string<_CharT, _Traits, _Allocator>::insert(const_iterator __pos, _ForwardIterator __first, _ForwardIterator __last)
-{
-#if _LIBCPP_DEBUG_LEVEL == 2
-    _LIBCPP_ASSERT(__get_const_db()->__find_c_from_i(&__pos) == this,
-        "string::insert(iterator, range) called with an iterator not"
-        " referring to this string");
-#endif
-    size_type __ip = static_cast<size_type>(__pos - begin());
-    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
+_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)
+
+template <class _CharT, class _Traits, class _Allocator>
+template<class _ForwardIterator>
+_LIBCPP_CONSTEXPR_AFTER_CXX17
+__enable_if_t
+<
+    __is_cpp17_forward_iterator<_ForwardIterator>::value,
+    typename basic_string<_CharT, _Traits, _Allocator>::iterator
+>
+basic_string<_CharT, _Traits, _Allocator>::insert(const_iterator __pos, _ForwardIterator __first, _ForwardIterator __last)
+{
+#if _LIBCPP_DEBUG_LEVEL == 2
+  if (!__libcpp_is_constant_evaluated())
+    _LIBCPP_ASSERT(__get_const_db()->__find_c_from_i(&__pos) == this,
+        "string::insert(iterator, range) called with an iterator not"
+        " referring to this string");
+#endif
+    size_type __ip = static_cast<size_type>(__pos - begin());
+    size_type __n = static_cast<size_type>(_VSTD::distance(__first, __last));
+    if (__n)
+    {
+        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 _LIBCPP_CONSTEXPR_AFTER_CXX17
 basic_string<_CharT, _Traits, _Allocator>&
 basic_string<_CharT, _Traits, _Allocator>::insert(size_type __pos1, const basic_string& __str)

 }
 
 template <class _CharT, class _Traits, class _Allocator>
 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)
 {
 #if _LIBCPP_DEBUG_LEVEL == 2
+  if (!__libcpp_is_constant_evaluated())
     _LIBCPP_ASSERT(__get_const_db()->__find_c_from_i(&__pos) == this,
         "string::insert(iterator, n, value) called with an iterator not"
         " referring to this string");
 #endif
     difference_type __p = __pos - begin();
     insert(static_cast<size_type>(__p), __n, __c);
     return begin() + __p;
 }
 
 // replace
 
-template <class _CharT, class _Traits, class _Allocator>
+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
 {
     _LIBCPP_ASSERT(__n2 == 0 || __s != nullptr, "string::replace received nullptr");
     size_type __sz = size();
     if (__pos > __sz)
         this->__throw_out_of_range();
     __n1 = _VSTD::min(__n1, __sz - __pos);
     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)
         {
             size_type __n_move = __sz - __pos - __n1;
             if (__n_move != 0)
             {
                 if (__n1 > __n2)
                 {

 }
 
 template <class _CharT, class _Traits, class _Allocator>
 inline _LIBCPP_CONSTEXPR_AFTER_CXX17
 typename basic_string<_CharT, _Traits, _Allocator>::iterator
 basic_string<_CharT, _Traits, _Allocator>::erase(const_iterator __pos)
 {
 #if _LIBCPP_DEBUG_LEVEL == 2
+  if (!__libcpp_is_constant_evaluated())
     _LIBCPP_ASSERT(__get_const_db()->__find_c_from_i(&__pos) == this,
         "string::erase(iterator) called with an iterator not"
         " referring to this string");
 #endif
     _LIBCPP_ASSERT(__pos != end(),
         "string::erase(iterator) called with a non-dereferenceable iterator");
     iterator __b = begin();
     size_type __r = static_cast<size_type>(__pos - __b);
     erase(__r, 1);
     return __b + static_cast<difference_type>(__r);
 }
 
 template <class _CharT, class _Traits, class _Allocator>
 inline _LIBCPP_CONSTEXPR_AFTER_CXX17
 typename basic_string<_CharT, _Traits, _Allocator>::iterator
 basic_string<_CharT, _Traits, _Allocator>::erase(const_iterator __first, const_iterator __last)
 {
 #if _LIBCPP_DEBUG_LEVEL == 2
+  if (!__libcpp_is_constant_evaluated())
     _LIBCPP_ASSERT(__get_const_db()->__find_c_from_i(&__first) == this,
         "string::erase(iterator,  iterator) called with an iterator not"
         " referring to this string");
 #endif
     _LIBCPP_ASSERT(__first <= __last, "string::erase(first, last) called with invalid range");
     iterator __b = begin();
     size_type __r = static_cast<size_type>(__first - __b);
     erase(__r, static_cast<size_type>(__last - __first));

 void
 basic_string<_CharT, _Traits, _Allocator>::__shrink_or_extend(size_type __target_capacity)
 {
     size_type __cap = capacity();
     size_type __sz = size();
 
     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;
         __new_data = __get_short_pointer();
         __p = __get_long_pointer();
     }
     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
             try
             {
         #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 (...)
             {
                 return;
             }
         #else  // _LIBCPP_NO_EXCEPTIONS
             if (__new_data == nullptr)

 #if _LIBCPP_STD_VER >= 14
         _NOEXCEPT
 #else
         _NOEXCEPT_(!__alloc_traits::propagate_on_container_swap::value ||
                     __is_nothrow_swappable<allocator_type>::value)
 #endif
 {
 #if _LIBCPP_DEBUG_LEVEL == 2
+  if (!__libcpp_is_constant_evaluated()) {
     if (!__is_long())
         __get_db()->__invalidate_all(this);
     if (!__str.__is_long())
         __get_db()->__invalidate_all(&__str);
     __get_db()->swap(this, &__str);
+  }
 #endif
     _LIBCPP_ASSERT(
         __alloc_traits::propagate_on_container_swap::value ||
         __alloc_traits::is_always_equal::value ||
         __alloc() == __str.__alloc(), "swapping non-equal allocators");
     _VSTD::swap(__r_.first(), __str.__r_.first());
     _VSTD::__swap_allocator(__alloc(), __str.__alloc());
 }

 
 // __invariants
 
 template<class _CharT, class _Traits, class _Allocator>
 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;
     if (data()[size()] != value_type())
         return false;
     return true;
 }
 
 // __clear_and_shrink
 
 template<class _CharT, class _Traits, class _Allocator>
 inline _LIBCPP_CONSTEXPR_AFTER_CXX17
 void
 basic_string<_CharT, _Traits, _Allocator>::__clear_and_shrink() _NOEXCEPT
 {
     clear();
     if(__is_long())
     {
         __alloc_traits::deallocate(__alloc(), __get_long_pointer(), capacity() + 1);
+        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_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY
 bool
 operator==(const basic_string<_CharT, _Traits, _Allocator>& __lhs,
            const basic_string<_CharT, _Traits, _Allocator>& __rhs) _NOEXCEPT

 
 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)
 {
     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 _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;
 }
 
 #ifndef _LIBCPP_CXX03_LANG
 
 template<class _CharT, class _Traits, class _Allocator>

libcxx/test/std/input.output/iostream.format/quoted.manip/quoted_traits.verify.cpp

 #include <cassert>
 
 #include "test_macros.h"
 
 //  Test that mismatches in the traits between the quoted object and the dest string are diagnosed.
 
 template <class charT>
 struct test_traits {
-    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::basic_string<char, test_traits<char> > s;
 }
 
-int main(int, char**) {
-    round_trip("Hi Mom");
-}
+int main(int, char**) { round_trip("Hi Mom"); }

libcxx/test/std/strings/basic.string/string.access/at.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <string>
 
 // const_reference at(size_type pos) const;
 //       reference at(size_type pos);
 
 #include <string>
 #include <stdexcept>
 #include <cassert>
 
 #include "min_allocator.h"
 
 #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) {
+  if (pos < s.size()) {
 #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 if (!TEST_IS_CONSTANT_EVALUATED) {
+    try {
+    } catch (std::out_of_range&) {
+    try {
+    } catch (std::out_of_range&) {
 #endif
 }
 
-int main(int, char**)
-{
-    {
+TEST_CONSTEXPR_CXX20 bool test() {
     typedef std::string S;
     test(S(), 0);
     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;
+    typedef std::basic_string<char, std::char_traits<char>, min_allocator<char> > S;
     test(S(), 0);
     test(S("123"), 0);
     test(S("123"), 1);
     test(S("123"), 2);
     test(S("123"), 3);
-    }
 #endif
+  return true;
+}
+
+int main(int, char**) {
+  test();
+#if TEST_STD_VER > 17
+  static_assert(test());
+#endif
 
   return 0;
 }

libcxx/test/std/strings/basic.string/string.capacity/clear.pass.cpp

 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S>
-void
-test(S s)
-{
-    s.clear();
-    assert(s.size() == 0);
+TEST_CONSTEXPR_CXX20 void test(S s) {
 }
 
-int main(int, char**)
-{
-    {
+TEST_CONSTEXPR_CXX20
+bool test() {
     typedef std::string S;
     S s;
     test(s);
 
     s.assign(10, 'a');
     s.erase(5);
     test(s);
 
#if TEST_STD_VER >= 11
     test(s);
 
     s.assign(100, 'a');
     s.erase(50);
     test(s);
     }
 #endif
 
+    return true;
+}
+
+int main(int, char**) {
+  test();
+#if TEST_STD_VER > 17
+  static_assert(test());
+#endif
+
   return 0;
 }

libcxx/test/std/strings/basic.string/string.cons/substr.pass.cpp

 #include <scoped_allocator>
 #include <cassert>
 
 #include "test_macros.h"
 #include "test_allocator.h"
 #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;
+TEST_CONSTEXPR_CXX20 void test(S str, unsigned pos) {
 
-    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());
-    }
+  if (pos <= str.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 {
+    } catch (std::out_of_range&) {
 #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) {
+  if (pos <= str.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 {
+    } catch (std::out_of_range&) {
 #endif
 }
 
 template <class S>
-void
-test(S str, unsigned pos, unsigned n, const typename S::allocator_type& a)
-{
-    typedef typename S::traits_type T;
+TEST_CONSTEXPR_CXX20 void test(S str, unsigned pos, unsigned n, const typename S::allocator_type& a) {
 
-    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());
-    }
+  if (pos <= str.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 {
+    } catch (std::out_of_range&) {
 #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);
+void test2583() { // LWG #2583
+  typedef std::basic_string<char, std::char_traits<char>, test_allocator<char>> StringA;
 
-    try { vs.emplace_back(s, 5); }
-    catch (const std::out_of_range&) { return; }
-    assert(false);
+  try {
+    vs.emplace_back(s, 5);
+  } catch (const std::out_of_range&) {
+    return;
+  }
 }
 #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;
 
     test(S(A(3)), 0);
     test(S(A(3)), 1);
     test(S("1", A(5)), 0);
     test(S("1", A(5)), 1);
     test(S("1", A(5)), 2);
bool test() {
     test(S(A(3)), 1, 1, A(4));
     test(S(A(3)), 1, 2, A(4));
     test(S("1", A(5)), 0, 0, A(6));
     test(S("1", A(5)), 0, 1, A(6));
     test(S("1234567890123456789012345678901234567890123456789012345678901234567890", A(7)), 50, 0, A(8));
     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;
 
     test(S(A()), 0);
     test(S(A()), 1);
     test(S("1", A()), 0);
     test(S("1", A()), 1);
     test(S("1", A()), 2);
#if TEST_STD_VER >= 11
     test(S(A()), 1, 1, A());
     test(S(A()), 1, 2, A());
     test(S("1", A()), 0, 0, A());
     test(S("1", A()), 0, 1, A());
     test(S("1234567890123456789012345678901234567890123456789012345678901234567890", A()), 50, 0, A());
     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
 #endif
 
+  return true;
+}
+
+int main(int, char**) {
+  test();
+#if TEST_STD_VER > 17
+  static_assert(test());
+#endif
+
   return 0;
 }

libcxx/test/std/strings/basic.string/string.contains/contains.char.pass.cpp

 // <string>
 
 //   constexpr bool contains(charT x) const noexcept;
 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 
-void test()
-{
-    using S = std::string;
+constexpr bool test() {
 
-    S s1 {};
-    S s2 {"abcde", 5};
+  S s1{};
+  S s2{"abcde", 5};
 
-    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(s2.contains('c'));
+  assert(s2.contains('e'));
+
+  return true;
 }
 
-int main(int, char**)
-{
-    test();
+int main(int, char**) {
+
+  static_assert(test());
 
-    return 0;
 }

libcxx/test/std/strings/basic.string/string.contains/contains.ptr.pass.cpp

 
 //   constexpr bool contains(const CharT *x) const;
 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 
-void test()
-{
-    using S = std::string;
+constexpr bool test() {
 
-    const char* s = "abcde";
-    S s0;
-    S s1 {s + 4, 1};
-    S s3 {s + 2, 3};
-    S sNot {"xyz", 3};
+  S s1{s + 4, 1};
+  S s3{s + 2, 3};
+  S sNot{"xyz", 3};
 
-    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("e"));
 
-    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("cde"));
 
-    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("xyz"));
+
+  return true;
 }
 
-int main(int, char**)
-{
-    test();
+int main(int, char**) {
+
+  static_assert(test());
 
-    return 0;
 }

libcxx/test/std/strings/basic.string/string.iterators/iterators.pass.cpp

 // const_iterator cbegin() const;
 // const_iterator cend()   const;
 
 #include <string>
 #include <cassert>
 
 #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() {
+    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() {
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
-    test<std::wstring>();
 #endif
 
 #if defined(__cpp_lib_char8_t) && __cpp_lib_char8_t >= 201811L
     test<std::u8string>();
 #endif
 
     test<std::u16string>();
     test<std::u32string>();
 
-    return 0;
+    return true;
+}
+
+int main(int, char**) {
+  test();
+#if TEST_STD_VER > 17
+  static_assert(test());
+#endif
+
 }

libcxx/test/std/strings/basic.string/string.modifiers/string_insert/size_pointer_size.pass.cpp

 #include <string>
 #include <stdexcept>
 #include <cassert>
 
 #include "test_macros.h"
 #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)
 {
     const typename S::size_type old_size = s.size();
     S s0 = s;
     if (pos <= old_size)
     {
         s.insert(pos, str, n);
         LIBCPP_ASSERT(s.__invariants());
         assert(s == expected);
     }
 #ifndef TEST_HAS_NO_EXCEPTIONS
-    else
+    else if (!TEST_IS_CONSTANT_EVALUATED)
     {
         try
         {
             s.insert(pos, str, n);
             assert(false);
         }
         catch (std::out_of_range&)
         {
             assert(pos > old_size);
             assert(s == s0);
         }
     }
 #endif
 }
 
-int main(int, char**)
-{
+TEST_CONSTEXPR_CXX20 bool test() {
     {
     typedef std::string S;
     test(S(""), 0, "", 0, S(""));
     test(S(""), 0, "12345", 0, S(""));
     test(S(""), 0, "12345", 1, S("1"));
     test(S(""), 0, "12345", 2, S("12"));
     test(S(""), 0, "12345", 4, S("1234"));
     test(S(""), 0, "12345", 5, S("12345"));
     test(S(""), 0, "1234567890", 0, S(""));
     test(S(""), 0, "1234567890", 1, S("1"));
#endif
     assert(s_short == "123/123/123/123/");
     s_short.insert(0, s_short.data(), s_short.size());
     assert(s_short == "123/123/123/123/123/123/123/123/");
 
     s_long.insert(0, s_long.data(), s_long.size());
     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;
 }

libcxx/test/std/strings/basic.string/string.modifiers/string_insert/size_string_size_size.pass.cpp

 #include <string>
 #include <stdexcept>
 #include <cassert>
 
 #include "test_macros.h"
 #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)
 {
     const typename S::size_type old_size = s.size();
     S s0 = s;
     if (pos1 <= old_size && pos2 <= str.size())
     {
         s.insert(pos1, str, pos2, n);
         LIBCPP_ASSERT(s.__invariants());
         assert(s == expected);
     }
 #ifndef TEST_HAS_NO_EXCEPTIONS
-    else
+    else if (!TEST_IS_CONSTANT_EVALUATED)
     {
         try
         {
             s.insert(pos1, str, pos2, n);
             assert(false);
         }
         catch (std::out_of_range&)
         {
             assert(pos1 > old_size || pos2 > str.size());
             assert(s == s0);
         }
     }
 #endif
 }
 
 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();
     S s0 = s;
     if (pos1 <= old_size && pos2 <= str.size())
     {
         s.insert(pos1, str, pos2);
         LIBCPP_ASSERT(s.__invariants());
         assert(s == expected);
     }
 #ifndef TEST_HAS_NO_EXCEPTIONS
-    else
+    else if (!TEST_IS_CONSTANT_EVALUATED)
     {
         try
         {
             s.insert(pos1, str, pos2);
             assert(false);
         }
         catch (std::out_of_range&)
         {
             assert(pos1 > old_size || pos2 > str.size());
             assert(s == s0);
         }
     }
 #endif
 }
 
 
 template <class S>
-void test0()
+TEST_CONSTEXPR_CXX20 bool test0()
 {
     test(S(""), 0, S(""), 0, 0, S(""));
     test(S(""), 0, S(""), 0, 1, S(""));
     test(S(""), 0, S(""), 1, 0, S("can't happen"));
     test(S(""), 0, S("12345"), 0, 0, S(""));
     test(S(""), 0, S("12345"), 0, 1, S("1"));
     test(S(""), 0, S("12345"), 0, 2, S("12"));
     test(S(""), 0, S("12345"), 0, 4, S("1234"));
TEST_CONSTEXPR_CXX20 bool test0()
     test(S(""), 0, S("1234567890"), 5, 5, S("67890"));
     test(S(""), 0, S("1234567890"), 5, 6, S("67890"));
     test(S(""), 0, S("1234567890"), 9, 0, S(""));
     test(S(""), 0, S("1234567890"), 9, 1, S("0"));
     test(S(""), 0, S("1234567890"), 9, 2, S("0"));
     test(S(""), 0, S("1234567890"), 10, 0, S(""));
     test(S(""), 0, S("1234567890"), 10, 1, S(""));
     test(S(""), 0, S("1234567890"), 11, 0, S("can't happen"));
+
+    return true;
 }
 
 template <class S>
-void test1()
+TEST_CONSTEXPR_CXX20 bool test1()
 {
     test(S(""), 0, S("12345678901234567890"), 0, 0, S(""));
     test(S(""), 0, S("12345678901234567890"), 0, 1, S("1"));
     test(S(""), 0, S("12345678901234567890"), 0, 10, S("1234567890"));
     test(S(""), 0, S("12345678901234567890"), 0, 19, S("1234567890123456789"));
     test(S(""), 0, S("12345678901234567890"), 0, 20, S("12345678901234567890"));
     test(S(""), 0, S("12345678901234567890"), 0, 21, S("12345678901234567890"));
     test(S(""), 0, S("12345678901234567890"), 1, 0, S(""));
TEST_CONSTEXPR_CXX20 bool test1()
     test(S(""), 1, S("12345"), 2, 3, S("can't happen"));
     test(S(""), 1, S("12345"), 2, 4, S("can't happen"));
     test(S(""), 1, S("12345"), 4, 0, S("can't happen"));
     test(S(""), 1, S("12345"), 4, 1, S("can't happen"));
     test(S(""), 1, S("12345"), 4, 2, S("can't happen"));
     test(S(""), 1, S("12345"), 5, 0, S("can't happen"));
     test(S(""), 1, S("12345"), 5, 1, S("can't happen"));
     test(S(""), 1, S("12345"), 6, 0, S("can't happen"));
+
+    return true;
 }
 
 template <class S>
-void test2()
+TEST_CONSTEXPR_CXX20 bool test2()
 {
     test(S(""), 1, S("1234567890"), 0, 0, S("can't happen"));
     test(S(""), 1, S("1234567890"), 0, 1, S("can't happen"));
     test(S(""), 1, S("1234567890"), 0, 5, S("can't happen"));
     test(S(""), 1, S("1234567890"), 0, 9, S("can't happen"));
     test(S(""), 1, S("1234567890"), 0, 10, S("can't happen"));
     test(S(""), 1, S("1234567890"), 0, 11, S("can't happen"));
     test(S(""), 1, S("1234567890"), 1, 0, S("can't happen"));
TEST_CONSTEXPR_CXX20 bool test2()
     test(S(""), 1, S("12345678901234567890"), 19, 0, S("can't happen"));
     test(S(""), 1, S("12345678901234567890"), 19, 1, S("can't happen"));
     test(S(""), 1, S("12345678901234567890"), 19, 2, S("can't happen"));
     test(S(""), 1, S("12345678901234567890"), 20, 0, S("can't happen"));
     test(S(""), 1, S("12345678901234567890"), 20, 1, S("can't happen"));
     test(S(""), 1, S("12345678901234567890"), 21, 0, S("can't happen"));
     test(S("abcde"), 0, S(""), 0, 0, S("abcde"));
     test(S("abcde"), 0, S(""), 0, 1, S("abcde"));
+
+    return true;
 }
 
 template <class S>
-void test3()
+TEST_CONSTEXPR_CXX20 bool test3()
 {
     test(S("abcde"), 0, S(""), 1, 0, S("can't happen"));
     test(S("abcde"), 0, S("12345"), 0, 0, S("abcde"));
     test(S("abcde"), 0, S("12345"), 0, 1, S("1abcde"));
     test(S("abcde"), 0, S("12345"), 0, 2, S("12abcde"));
     test(S("abcde"), 0, S("12345"), 0, 4, S("1234abcde"));
     test(S("abcde"), 0, S("12345"), 0, 5, S("12345abcde"));
     test(S("abcde"), 0, S("12345"), 0, 6, S("12345abcde"));
TEST_CONSTEXPR_CXX20 bool test3()
     test(S("abcde"), 0, S("1234567890"), 9, 0, S("abcde"));
     test(S("abcde"), 0, S("1234567890"), 9, 1, S("0abcde"));
     test(S("abcde"), 0, S("1234567890"), 9, 2, S("0abcde"));
     test(S("abcde"), 0, S("1234567890"), 10, 0, S("abcde"));
     test(S("abcde"), 0, S("1234567890"), 10, 1, S("abcde"));
     test(S("abcde"), 0, S("1234567890"), 11, 0, S("can't happen"));
     test(S("abcde"), 0, S("12345678901234567890"), 0, 0, S("abcde"));
     test(S("abcde"), 0, S("12345678901234567890"), 0, 1, S("1abcde"));
+
+    return true;
 }
 
 template <class S>
-void test4()
+TEST_CONSTEXPR_CXX20 bool test4()
 {
     test(S("abcde"), 0, S("12345678901234567890"), 0, 10, S("1234567890abcde"));
     test(S("abcde"), 0, S("12345678901234567890"), 0, 19, S("1234567890123456789abcde"));
     test(S("abcde"), 0, S("12345678901234567890"), 0, 20, S("12345678901234567890abcde"));
     test(S("abcde"), 0, S("12345678901234567890"), 0, 21, S("12345678901234567890abcde"));
     test(S("abcde"), 0, S("12345678901234567890"), 1, 0, S("abcde"));
     test(S("abcde"), 0, S("12345678901234567890"), 1, 1, S("2abcde"));
     test(S("abcde"), 0, S("12345678901234567890"), 1, 9, S("234567890abcde"));
TEST_CONSTEXPR_CXX20 bool test4()
     test(S("abcde"), 1, S("12345"), 4, 0, S("abcde"));
     test(S("abcde"), 1, S("12345"), 4, 1, S("a5bcde"));
     test(S("abcde"), 1, S("12345"), 4, 2, S("a5bcde"));
     test(S("abcde"), 1, S("12345"), 5, 0, S("abcde"));
     test(S("abcde"), 1, S("12345"), 5, 1, S("abcde"));
     test(S("abcde"), 1, S("12345"), 6, 0, S("can't happen"));
     test(S("abcde"), 1, S("1234567890"), 0, 0, S("abcde"));
     test(S("abcde"), 1, S("1234567890"), 0, 1, S("a1bcde"));
+
+    return true;
 }
 
 template <class S>
-void test5()
+TEST_CONSTEXPR_CXX20 bool test5()
 {
     test(S("abcde"), 1, S("1234567890"), 0, 5, S("a12345bcde"));
     test(S("abcde"), 1, S("1234567890"), 0, 9, S("a123456789bcde"));
     test(S("abcde"), 1, S("1234567890"), 0, 10, S("a1234567890bcde"));
     test(S("abcde"), 1, S("1234567890"), 0, 11, S("a1234567890bcde"));
     test(S("abcde"), 1, S("1234567890"), 1, 0, S("abcde"));
     test(S("abcde"), 1, S("1234567890"), 1, 1, S("a2bcde"));
     test(S("abcde"), 1, S("1234567890"), 1, 4, S("a2345bcde"));
TEST_CONSTEXPR_CXX20 bool test5()
     test(S("abcde"), 1, S("12345678901234567890"), 19, 2, S("a0bcde"));
     test(S("abcde"), 1, S("12345678901234567890"), 20, 0, S("abcde"));
     test(S("abcde"), 1, S("12345678901234567890"), 20, 1, S("abcde"));
     test(S("abcde"), 1, S("12345678901234567890"), 21, 0, S("can't happen"));
     test(S("abcde"), 2, S(""), 0, 0, S("abcde"));
     test(S("abcde"), 2, S(""), 0, 1, S("abcde"));
     test(S("abcde"), 2, S(""), 1, 0, S("can't happen"));
     test(S("abcde"), 2, S("12345"), 0, 0, S("abcde"));
+
+    return true;
 }
 
 template <class S>
-void test6()
+TEST_CONSTEXPR_CXX20 bool test6()
 {
     test(S("abcde"), 2, S("12345"), 0, 1, S("ab1cde"));
     test(S("abcde"), 2, S("12345"), 0, 2, S("ab12cde"));
     test(S("abcde"), 2, S("12345"), 0, 4, S("ab1234cde"));
     test(S("abcde"), 2, S("12345"), 0, 5, S("ab12345cde"));
     test(S("abcde"), 2, S("12345"), 0, 6, S("ab12345cde"));
     test(S("abcde"), 2, S("12345"), 1, 0, S("abcde"));
     test(S("abcde"), 2, S("12345"), 1, 1, S("ab2cde"));
TEST_CONSTEXPR_CXX20 bool test6()
     test(S("abcde"), 2, S("1234567890"), 9, 2, S("ab0cde"));
     test(S("abcde"), 2, S("1234567890"), 10, 0, S("abcde"));
     test(S("abcde"), 2, S("1234567890"), 10, 1, S("abcde"));
     test(S("abcde"), 2, S("1234567890"), 11, 0, S("can't happen"));
     test(S("abcde"), 2, S("12345678901234567890"), 0, 0, S("abcde"));
     test(S("abcde"), 2, S("12345678901234567890"), 0, 1, S("ab1cde"));
     test(S("abcde"), 2, S("12345678901234567890"), 0, 10, S("ab1234567890cde"));
     test(S("abcde"), 2, S("12345678901234567890"), 0, 19, S("ab1234567890123456789cde"));
+
+    return true;
 }
 
 template <class S>
-void test7()
+TEST_CONSTEXPR_CXX20 bool test7()
 {
     test(S("abcde"), 2, S("12345678901234567890"), 0, 20, S("ab12345678901234567890cde"));
     test(S("abcde"), 2, S("12345678901234567890"), 0, 21, S("ab12345678901234567890cde"));
     test(S("abcde"), 2, S("12345678901234567890"), 1, 0, S("abcde"));
     test(S("abcde"), 2, S("12345678901234567890"), 1, 1, S("ab2cde"));
     test(S("abcde"), 2, S("12345678901234567890"), 1, 9, S("ab234567890cde"));
     test(S("abcde"), 2, S("12345678901234567890"), 1, 18, S("ab234567890123456789cde"));
     test(S("abcde"), 2, S("12345678901234567890"), 1, 19, S("ab2345678901234567890cde"));
TEST_CONSTEXPR_CXX20 bool test7()
     test(S("abcde"), 4, S("12345"), 4, 2, S("abcd5e"));
     test(S("abcde"), 4, S("12345"), 5, 0, S("abcde"));
     test(S("abcde"), 4, S("12345"), 5, 1, S("abcde"));
     test(S("abcde"), 4, S("12345"), 6, 0, S("can't happen"));
     test(S("abcde"), 4, S("1234567890"), 0, 0, S("abcde"));
     test(S("abcde"), 4, S("1234567890"), 0, 1, S("abcd1e"));
     test(S("abcde"), 4, S("1234567890"), 0, 5, S("abcd12345e"));
     test(S("abcde"), 4, S("1234567890"), 0, 9, S("abcd123456789e"));
+
+    return true;
 }
 
 template <class S>
-void test8()
+TEST_CONSTEXPR_CXX20 bool test8()
 {
     test(S("abcde"), 4, S("1234567890"), 0, 10, S("abcd1234567890e"));
     test(S("abcde"), 4, S("1234567890"), 0, 11, S("abcd1234567890e"));
     test(S("abcde"), 4, S("1234567890"), 1, 0, S("abcde"));
     test(S("abcde"), 4, S("1234567890"), 1, 1, S("abcd2e"));
     test(S("abcde"), 4, S("1234567890"), 1, 4, S("abcd2345e"));
     test(S("abcde"), 4, S("1234567890"), 1, 8, S("abcd23456789e"));
     test(S("abcde"), 4, S("1234567890"), 1, 9, S("abcd234567890e"));
TEST_CONSTEXPR_CXX20 bool test8()
     test(S("abcde"), 4, S("12345678901234567890"), 20, 1, S("abcde"));
     test(S("abcde"), 4, S("12345678901234567890"), 21, 0, S("can't happen"));
     test(S("abcde"), 5, S(""), 0, 0, S("abcde"));
     test(S("abcde"), 5, S(""), 0, 1, S("abcde"));
     test(S("abcde"), 5, S(""), 1, 0, S("can't happen"));
     test(S("abcde"), 5, S("12345"), 0, 0, S("abcde"));
     test(S("abcde"), 5, S("12345"), 0, 1, S("abcde1"));
     test(S("abcde"), 5, S("12345"), 0, 2, S("abcde12"));
+
+    return true;
 }
 
 template <class S>
-void test9()
+TEST_CONSTEXPR_CXX20 bool test9()
 {
     test(S("abcde"), 5, S("12345"), 0, 4, S("abcde1234"));
     test(S("abcde"), 5, S("12345"), 0, 5, S("abcde12345"));
     test(S("abcde"), 5, S("12345"), 0, 6, S("abcde12345"));
     test(S("abcde"), 5, S("12345"), 1, 0, S("abcde"));
     test(S("abcde"), 5, S("12345"), 1, 1, S("abcde2"));
     test(S("abcde"), 5, S("12345"), 1, 2, S("abcde23"));
     test(S("abcde"), 5, S("12345"), 1, 3, S("abcde234"));
TEST_CONSTEXPR_CXX20 bool test9()
     test(S("abcde"), 5, S("1234567890"), 10, 1, S("abcde"));
     test(S("abcde"), 5, S("1234567890"), 11, 0, S("can't happen"));
     test(S("abcde"), 5, S("12345678901234567890"), 0, 0, S("abcde"));
     test(S("abcde"), 5, S("12345678901234567890"), 0, 1, S("abcde1"));
     test(S("abcde"), 5, S("12345678901234567890"), 0, 10, S("abcde1234567890"));
     test(S("abcde"), 5, S("12345678901234567890"), 0, 19, S("abcde1234567890123456789"));
     test(S("abcde"), 5, S("12345678901234567890"), 0, 20, S("abcde12345678901234567890"));
     test(S("abcde"), 5, S("12345678901234567890"), 0, 21, S("abcde12345678901234567890"));
+
+    return true;
 }
 
 template <class S>
-void test10()
+TEST_CONSTEXPR_CXX20 bool test10()
 {
     test(S("abcde"), 5, S("12345678901234567890"), 1, 0, S("abcde"));
     test(S("abcde"), 5, S("12345678901234567890"), 1, 1, S("abcde2"));
     test(S("abcde"), 5, S("12345678901234567890"), 1, 9, S("abcde234567890"));
     test(S("abcde"), 5, S("12345678901234567890"), 1, 18, S("abcde234567890123456789"));
     test(S("abcde"), 5, S("12345678901234567890"), 1, 19, S("abcde2345678901234567890"));
     test(S("abcde"), 5, S("12345678901234567890"), 1, 20, S("abcde2345678901234567890"));
     test(S("abcde"), 5, S("12345678901234567890"), 10, 0, S("abcde"));
TEST_CONSTEXPR_CXX20 bool test10()
     test(S("abcde"), 6, S("12345"), 5, 1, S("can't happen"));
     test(S("abcde"), 6, S("12345"), 6, 0, S("can't happen"));
     test(S("abcde"), 6, S("1234567890"), 0, 0, S("can't happen"));
     test(S("abcde"), 6, S("1234567890"), 0, 1, S("can't happen"));
     test(S("abcde"), 6, S("1234567890"), 0, 5, S("can't happen"));
     test(S("abcde"), 6, S("1234567890"), 0, 9, S("can't happen"));
     test(S("abcde"), 6, S("1234567890"), 0, 10, S("can't happen"));
     test(S("abcde"), 6, S("1234567890"), 0, 11, S("can't happen"));
+
+    return true;
 }
 
 template <class S>
-void test11()
+TEST_CONSTEXPR_CXX20 bool 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"));
     test(S("abcde"), 6, S("1234567890"), 1, 4, S("can't happen"));
     test(S("abcde"), 6, S("1234567890"), 1, 8, S("can't happen"));
     test(S("abcde"), 6, S("1234567890"), 1, 9, S("can't happen"));
     test(S("abcde"), 6, S("1234567890"), 1, 10, S("can't happen"));
     test(S("abcde"), 6, S("1234567890"), 5, 0, S("can't happen"));
TEST_CONSTEXPR_CXX20 bool test11()
     test(S("abcdefghij"), 0, S(""), 0, 0, S("abcdefghij"));
     test(S("abcdefghij"), 0, S(""), 0, 1, S("abcdefghij"));
     test(S("abcdefghij"), 0, S(""), 1, 0, S("can't happen"));
     test(S("abcdefghij"), 0, S("12345"), 0, 0, S("abcdefghij"));
     test(S("abcdefghij"), 0, S("12345"), 0, 1, S("1abcdefghij"));
     test(S("abcdefghij"), 0, S("12345"), 0, 2, S("12abcdefghij"));
     test(S("abcdefghij"), 0, S("12345"), 0, 4, S("1234abcdefghij"));
     test(S("abcdefghij"), 0, S("12345"), 0, 5, S("12345abcdefghij"));
+
+    return true;
 }
 
 template <class S>
-void test12()
+TEST_CONSTEXPR_CXX20 bool test12()
 {
     test(S("abcdefghij"), 0, S("12345"), 0, 6, S("12345abcdefghij"));
     test(S("abcdefghij"), 0, S("12345"), 1, 0, S("abcdefghij"));
     test(S("abcdefghij"), 0, S("12345"), 1, 1, S("2abcdefghij"));
     test(S("abcdefghij"), 0, S("12345"), 1, 2, S("23abcdefghij"));
     test(S("abcdefghij"), 0, S("12345"), 1, 3, S("234abcdefghij"));
     test(S("abcdefghij"), 0, S("12345"), 1, 4, S("2345abcdefghij"));
     test(S("abcdefghij"), 0, S("12345"), 1, 5, S("2345abcdefghij"));
TEST_CONSTEXPR_CXX20 bool test12()
     test(S("abcdefghij"), 0, S("12345678901234567890"), 0, 0, S("abcdefghij"));
     test(S("abcdefghij"), 0, S("12345678901234567890"), 0, 1, S("1abcdefghij"));
     test(S("abcdefghij"), 0, S("12345678901234567890"), 0, 10, S("1234567890abcdefghij"));
     test(S("abcdefghij"), 0, S("12345678901234567890"), 0, 19, S("1234567890123456789abcdefghij"));
     test(S("abcdefghij"), 0, S("12345678901234567890"), 0, 20, S("12345678901234567890abcdefghij"));
     test(S("abcdefghij"), 0, S("12345678901234567890"), 0, 21, S("12345678901234567890abcdefghij"));
     test(S("abcdefghij"), 0, S("12345678901234567890"), 1, 0, S("abcdefghij"));
     test(S("abcdefghij"), 0, S("12345678901234567890"), 1, 1, S("2abcdefghij"));
+
+    return true;
 }
 
 template <class S>
-void test13()
+TEST_CONSTEXPR_CXX20 bool test13()
 {
     test(S("abcdefghij"), 0, S("12345678901234567890"), 1, 9, S("234567890abcdefghij"));
     test(S("abcdefghij"), 0, S("12345678901234567890"), 1, 18, S("234567890123456789abcdefghij"));
     test(S("abcdefghij"), 0, S("12345678901234567890"), 1, 19, S("2345678901234567890abcdefghij"));
     test(S("abcdefghij"), 0, S("12345678901234567890"), 1, 20, S("2345678901234567890abcdefghij"));
     test(S("abcdefghij"), 0, S("12345678901234567890"), 10, 0, S("abcdefghij"));
     test(S("abcdefghij"), 0, S("12345678901234567890"), 10, 1, S("1abcdefghij"));
     test(S("abcdefghij"), 0, S("12345678901234567890"), 10, 5, S("12345abcdefghij"));
TEST_CONSTEXPR_CXX20 bool test13()
     test(S("abcdefghij"), 1, S("1234567890"), 0, 0, S("abcdefghij"));
     test(S("abcdefghij"), 1, S("1234567890"), 0, 1, S("a1bcdefghij"));
     test(S("abcdefghij"), 1, S("1234567890"), 0, 5, S("a12345bcdefghij"));
     test(S("abcdefghij"), 1, S("1234567890"), 0, 9, S("a123456789bcdefghij"));
     test(S("abcdefghij"), 1, S("1234567890"), 0, 10, S("a1234567890bcdefghij"));
     test(S("abcdefghij"), 1, S("1234567890"), 0, 11, S("a1234567890bcdefghij"));
     test(S("abcdefghij"), 1, S("1234567890"), 1, 0, S("abcdefghij"));
     test(S("abcdefghij"), 1, S("1234567890"), 1, 1, S("a2bcdefghij"));
+
+    return true;
 }
 
 template <class S>
-void test14()
+TEST_CONSTEXPR_CXX20 bool test14()
 {
     test(S("abcdefghij"), 1, S("1234567890"), 1, 4, S("a2345bcdefghij"));
     test(S("abcdefghij"), 1, S("1234567890"), 1, 8, S("a23456789bcdefghij"));
     test(S("abcdefghij"), 1, S("1234567890"), 1, 9, S("a234567890bcdefghij"));
     test(S("abcdefghij"), 1, S("1234567890"), 1, 10, S("a234567890bcdefghij"));
     test(S("abcdefghij"), 1, S("1234567890"), 5, 0, S("abcdefghij"));
     test(S("abcdefghij"), 1, S("1234567890"), 5, 1, S("a6bcdefghij"));
     test(S("abcdefghij"), 1, S("1234567890"), 5, 2, S("a67bcdefghij"));
TEST_CONSTEXPR_CXX20 bool test14()
     test(S("abcdefghij"), 5, S(""), 1, 0, S("can't happen"));
     test(S("abcdefghij"), 5, S("12345"), 0, 0, S("abcdefghij"));
     test(S("abcdefghij"), 5, S("12345"), 0, 1, S("abcde1fghij"));
     test(S("abcdefghij"), 5, S("12345"), 0, 2, S("abcde12fghij"));
     test(S("abcdefghij"), 5, S("12345"), 0, 4, S("abcde1234fghij"));
     test(S("abcdefghij"), 5, S("12345"), 0, 5, S("abcde12345fghij"));
     test(S("abcdefghij"), 5, S("12345"), 0, 6, S("abcde12345fghij"));
     test(S("abcdefghij"), 5, S("12345"), 1, 0, S("abcdefghij"));
+
+    return true;
 }
 
 template <class S>
-void test15()
+TEST_CONSTEXPR_CXX20 bool test15()
 {
     test(S("abcdefghij"), 5, S("12345"), 1, 1, S("abcde2fghij"));
     test(S("abcdefghij"), 5, S("12345"), 1, 2, S("abcde23fghij"));
     test(S("abcdefghij"), 5, S("12345"), 1, 3, S("abcde234fghij"));
     test(S("abcdefghij"), 5, S("12345"), 1, 4, S("abcde2345fghij"));
     test(S("abcdefghij"), 5, S("12345"), 1, 5, S("abcde2345fghij"));
     test(S("abcdefghij"), 5, S("12345"), 2, 0, S("abcdefghij"));
     test(S("abcdefghij"), 5, S("12345"), 2, 1, S("abcde3fghij"));
TEST_CONSTEXPR_CXX20 bool test15()
     test(S("abcdefghij"), 5, S("12345678901234567890"), 0, 10, S("abcde1234567890fghij"));
     test(S("abcdefghij"), 5, S("12345678901234567890"), 0, 19, S("abcde1234567890123456789fghij"));
     test(S("abcdefghij"), 5, S("12345678901234567890"), 0, 20, S("abcde12345678901234567890fghij"));
     test(S("abcdefghij"), 5, S("12345678901234567890"), 0, 21, S("abcde12345678901234567890fghij"));
     test(S("abcdefghij"), 5, S("12345678901234567890"), 1, 0, S("abcdefghij"));
     test(S("abcdefghij"), 5, S("12345678901234567890"), 1, 1, S("abcde2fghij"));
     test(S("abcdefghij"), 5, S("12345678901234567890"), 1, 9, S("abcde234567890fghij"));
     test(S("abcdefghij"), 5, S("12345678901234567890"), 1, 18, S("abcde234567890123456789fghij"));
+
+    return true;
 }
 
 template <class S>
-void test16()
+TEST_CONSTEXPR_CXX20 bool test16()
 {
     test(S("abcdefghij"), 5, S("12345678901234567890"), 1, 19, S("abcde2345678901234567890fghij"));
     test(S("abcdefghij"), 5, S("12345678901234567890"), 1, 20, S("abcde2345678901234567890fghij"));
     test(S("abcdefghij"), 5, S("12345678901234567890"), 10, 0, S("abcdefghij"));
     test(S("abcdefghij"), 5, S("12345678901234567890"), 10, 1, S("abcde1fghij"));
     test(S("abcdefghij"), 5, S("12345678901234567890"), 10, 5, S("abcde12345fghij"));
     test(S("abcdefghij"), 5, S("12345678901234567890"), 10, 9, S("abcde123456789fghij"));
     test(S("abcdefghij"), 5, S("12345678901234567890"), 10, 10, S("abcde1234567890fghij"));
TEST_CONSTEXPR_CXX20 bool test16()
     test(S("abcdefghij"), 9, S("1234567890"), 0, 5, S("abcdefghi12345j"));
     test(S("abcdefghij"), 9, S("1234567890"), 0, 9, S("abcdefghi123456789j"));
     test(S("abcdefghij"), 9, S("1234567890"), 0, 10, S("abcdefghi1234567890j"));
     test(S("abcdefghij"), 9, S("1234567890"), 0, 11, S("abcdefghi1234567890j"));
     test(S("abcdefghij"), 9, S("1234567890"), 1, 0, S("abcdefghij"));
     test(S("abcdefghij"), 9, S("1234567890"), 1, 1, S("abcdefghi2j"));
     test(S("abcdefghij"), 9, S("1234567890"), 1, 4, S("abcdefghi2345j"));
     test(S("abcdefghij"), 9, S("1234567890"), 1, 8, S("abcdefghi23456789j"));
+
+    return true;
 }
 
 template <class S>
-void test17()
+TEST_CONSTEXPR_CXX20 bool test17()
 {
     test(S("abcdefghij"), 9, S("1234567890"), 1, 9, S("abcdefghi234567890j"));
     test(S("abcdefghij"), 9, S("1234567890"), 1, 10, S("abcdefghi234567890j"));
     test(S("abcdefghij"), 9, S("1234567890"), 5, 0, S("abcdefghij"));
     test(S("abcdefghij"), 9, S("1234567890"), 5, 1, S("abcdefghi6j"));
     test(S("abcdefghij"), 9, S("1234567890"), 5, 2, S("abcdefghi67j"));
     test(S("abcdefghij"), 9, S("1234567890"), 5, 4, S("abcdefghi6789j"));
     test(S("abcdefghij"), 9, S("1234567890"), 5, 5, S("abcdefghi67890j"));
TEST_CONSTEXPR_CXX20 bool test17()
     test(S("abcdefghij"), 10, S("12345"), 0, 1, S("abcdefghij1"));
     test(S("abcdefghij"), 10, S("12345"), 0, 2, S("abcdefghij12"));
     test(S("abcdefghij"), 10, S("12345"), 0, 4, S("abcdefghij1234"));
     test(S("abcdefghij"), 10, S("12345"), 0, 5, S("abcdefghij12345"));
     test(S("abcdefghij"), 10, S("12345"), 0, 6, S("abcdefghij12345"));
     test(S("abcdefghij"), 10, S("12345"), 1, 0, S("abcdefghij"));
     test(S("abcdefghij"), 10, S("12345"), 1, 1, S("abcdefghij2"));
     test(S("abcdefghij"), 10, S("12345"), 1, 2, S("abcdefghij23"));
+
+    return true;
 }
 
 template <class S>
-void test18()
+TEST_CONSTEXPR_CXX20 bool test18()
 {
     test(S("abcdefghij"), 10, S("12345"), 1, 3, S("abcdefghij234"));
     test(S("abcdefghij"), 10, S("12345"), 1, 4, S("abcdefghij2345"));
     test(S("abcdefghij"), 10, S("12345"), 1, 5, S("abcdefghij2345"));
     test(S("abcdefghij"), 10, S("12345"), 2, 0, S("abcdefghij"));
     test(S("abcdefghij"), 10, S("12345"), 2, 1, S("abcdefghij3"));
     test(S("abcdefghij"), 10, S("12345"), 2, 2, S("abcdefghij34"));
     test(S("abcdefghij"), 10, S("12345"), 2, 3, S("abcdefghij345"));
TEST_CONSTEXPR_CXX20 bool test18()
     test(S("abcdefghij"), 10, S("12345678901234567890"), 0, 20, S("abcdefghij12345678901234567890"));
     test(S("abcdefghij"), 10, S("12345678901234567890"), 0, 21, S("abcdefghij12345678901234567890"));
     test(S("abcdefghij"), 10, S("12345678901234567890"), 1, 0, S("abcdefghij"));
     test(S("abcdefghij"), 10, S("12345678901234567890"), 1, 1, S("abcdefghij2"));
     test(S("abcdefghij"), 10, S("12345678901234567890"), 1, 9, S("abcdefghij234567890"));
     test(S("abcdefghij"), 10, S("12345678901234567890"), 1, 18, S("abcdefghij234567890123456789"));
     test(S("abcdefghij"), 10, S("12345678901234567890"), 1, 19, S("abcdefghij2345678901234567890"));
     test(S("abcdefghij"), 10, S("12345678901234567890"), 1, 20, S("abcdefghij2345678901234567890"));
+
+    return true;
 }
 
 template <class S>
-void test19()
+TEST_CONSTEXPR_CXX20 bool test19()
 {
     test(S("abcdefghij"), 10, S("12345678901234567890"), 10, 0, S("abcdefghij"));
     test(S("abcdefghij"), 10, S("12345678901234567890"), 10, 1, S("abcdefghij1"));
     test(S("abcdefghij"), 10, S("12345678901234567890"), 10, 5, S("abcdefghij12345"));
     test(S("abcdefghij"), 10, S("12345678901234567890"), 10, 9, S("abcdefghij123456789"));
     test(S("abcdefghij"), 10, S("12345678901234567890"), 10, 10, S("abcdefghij1234567890"));
     test(S("abcdefghij"), 10, S("12345678901234567890"), 10, 11, S("abcdefghij1234567890"));
     test(S("abcdefghij"), 10, S("12345678901234567890"), 19, 0, S("abcdefghij"));
TEST_CONSTEXPR_CXX20 bool test19()
     test(S("abcdefghij"), 11, S("1234567890"), 0, 10, S("can't happen"));
     test(S("abcdefghij"), 11, S("1234567890"), 0, 11, S("can't happen"));
     test(S("abcdefghij"), 11, S("1234567890"), 1, 0, S("can't happen"));
     test(S("abcdefghij"), 11, S("1234567890"), 1, 1, S("can't happen"));
     test(S("abcdefghij"), 11, S("1234567890"), 1, 4, S("can't happen"));
     test(S("abcdefghij"), 11, S("1234567890"), 1, 8, S("can't happen"));
     test(S("abcdefghij"), 11, S("1234567890"), 1, 9, S("can't happen"));
     test(S("abcdefghij"), 11, S("1234567890"), 1, 10, S("can't happen"));
+
+    return true;
 }
 
 template <class S>
-void test20()
+TEST_CONSTEXPR_CXX20 bool 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"));
     test(S("abcdefghij"), 11, S("1234567890"), 5, 2, S("can't happen"));
     test(S("abcdefghij"), 11, S("1234567890"), 5, 4, S("can't happen"));
     test(S("abcdefghij"), 11, S("1234567890"), 5, 5, S("can't happen"));
     test(S("abcdefghij"), 11, S("1234567890"), 5, 6, S("can't happen"));
     test(S("abcdefghij"), 11, S("1234567890"), 9, 0, S("can't happen"));
TEST_CONSTEXPR_CXX20 bool test20()
     test(S("abcdefghijklmnopqrst"), 0, S("12345"), 0, 4, S("1234abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 0, S("12345"), 0, 5, S("12345abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 0, S("12345"), 0, 6, S("12345abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 0, S("12345"), 1, 0, S("abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 0, S("12345"), 1, 1, S("2abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 0, S("12345"), 1, 2, S("23abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 0, S("12345"), 1, 3, S("234abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 0, S("12345"), 1, 4, S("2345abcdefghijklmnopqrst"));
+
+    return true;
 }
 
 template <class S>
-void test21()
+TEST_CONSTEXPR_CXX20 bool test21()
 {
     test(S("abcdefghijklmnopqrst"), 0, S("12345"), 1, 5, S("2345abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 0, S("12345"), 2, 0, S("abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 0, S("12345"), 2, 1, S("3abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 0, S("12345"), 2, 2, S("34abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 0, S("12345"), 2, 3, S("345abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 0, S("12345"), 2, 4, S("345abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 0, S("12345"), 4, 0, S("abcdefghijklmnopqrst"));
TEST_CONSTEXPR_CXX20 bool test21()
     test(S("abcdefghijklmnopqrst"), 0, S("12345678901234567890"), 1, 0, S("abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 0, S("12345678901234567890"), 1, 1, S("2abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 0, S("12345678901234567890"), 1, 9, S("234567890abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 0, S("12345678901234567890"), 1, 18, S("234567890123456789abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 0, S("12345678901234567890"), 1, 19, S("2345678901234567890abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 0, S("12345678901234567890"), 1, 20, S("2345678901234567890abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 0, S("12345678901234567890"), 10, 0, S("abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 0, S("12345678901234567890"), 10, 1, S("1abcdefghijklmnopqrst"));
+
+    return true;
 }
 
 template <class S>
-void test22()
+TEST_CONSTEXPR_CXX20 bool test22()
 {
     test(S("abcdefghijklmnopqrst"), 0, S("12345678901234567890"), 10, 5, S("12345abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 0, S("12345678901234567890"), 10, 9, S("123456789abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 0, S("12345678901234567890"), 10, 10, S("1234567890abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 0, S("12345678901234567890"), 10, 11, S("1234567890abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 0, S("12345678901234567890"), 19, 0, S("abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 0, S("12345678901234567890"), 19, 1, S("0abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 0, S("12345678901234567890"), 19, 2, S("0abcdefghijklmnopqrst"));
TEST_CONSTEXPR_CXX20 bool test22()
     test(S("abcdefghijklmnopqrst"), 1, S("1234567890"), 1, 0, S("abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 1, S("1234567890"), 1, 1, S("a2bcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 1, S("1234567890"), 1, 4, S("a2345bcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 1, S("1234567890"), 1, 8, S("a23456789bcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 1, S("1234567890"), 1, 9, S("a234567890bcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 1, S("1234567890"), 1, 10, S("a234567890bcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 1, S("1234567890"), 5, 0, S("abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 1, S("1234567890"), 5, 1, S("a6bcdefghijklmnopqrst"));
+
+    return true;
 }
 
 template <class S>
-void test23()
+TEST_CONSTEXPR_CXX20 bool test23()
 {
     test(S("abcdefghijklmnopqrst"), 1, S("1234567890"), 5, 2, S("a67bcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 1, S("1234567890"), 5, 4, S("a6789bcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 1, S("1234567890"), 5, 5, S("a67890bcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 1, S("1234567890"), 5, 6, S("a67890bcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 1, S("1234567890"), 9, 0, S("abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 1, S("1234567890"), 9, 1, S("a0bcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 1, S("1234567890"), 9, 2, S("a0bcdefghijklmnopqrst"));
TEST_CONSTEXPR_CXX20 bool test23()
     test(S("abcdefghijklmnopqrst"), 10, S("12345"), 0, 6, S("abcdefghij12345klmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 10, S("12345"), 1, 0, S("abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 10, S("12345"), 1, 1, S("abcdefghij2klmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 10, S("12345"), 1, 2, S("abcdefghij23klmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 10, S("12345"), 1, 3, S("abcdefghij234klmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 10, S("12345"), 1, 4, S("abcdefghij2345klmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 10, S("12345"), 1, 5, S("abcdefghij2345klmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 10, S("12345"), 2, 0, S("abcdefghijklmnopqrst"));
+
+    return true;
 }
 
 template <class S>
-void test24()
+TEST_CONSTEXPR_CXX20 bool test24()
 {
     test(S("abcdefghijklmnopqrst"), 10, S("12345"), 2, 1, S("abcdefghij3klmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 10, S("12345"), 2, 2, S("abcdefghij34klmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 10, S("12345"), 2, 3, S("abcdefghij345klmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 10, S("12345"), 2, 4, S("abcdefghij345klmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 10, S("12345"), 4, 0, S("abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 10, S("12345"), 4, 1, S("abcdefghij5klmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 10, S("12345"), 4, 2, S("abcdefghij5klmnopqrst"));
TEST_CONSTEXPR_CXX20 bool test24()
     test(S("abcdefghijklmnopqrst"), 10, S("12345678901234567890"), 1, 9, S("abcdefghij234567890klmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 10, S("12345678901234567890"), 1, 18, S("abcdefghij234567890123456789klmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 10, S("12345678901234567890"), 1, 19, S("abcdefghij2345678901234567890klmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 10, S("12345678901234567890"), 1, 20, S("abcdefghij2345678901234567890klmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 10, S("12345678901234567890"), 10, 0, S("abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 10, S("12345678901234567890"), 10, 1, S("abcdefghij1klmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 10, S("12345678901234567890"), 10, 5, S("abcdefghij12345klmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 10, S("12345678901234567890"), 10, 9, S("abcdefghij123456789klmnopqrst"));
+
+    return true;
 }
 
 template <class S>
-void test25()
+TEST_CONSTEXPR_CXX20 bool test25()
 {
     test(S("abcdefghijklmnopqrst"), 10, S("12345678901234567890"), 10, 10, S("abcdefghij1234567890klmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 10, S("12345678901234567890"), 10, 11, S("abcdefghij1234567890klmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 10, S("12345678901234567890"), 19, 0, S("abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 10, S("12345678901234567890"), 19, 1, S("abcdefghij0klmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 10, S("12345678901234567890"), 19, 2, S("abcdefghij0klmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 10, S("12345678901234567890"), 20, 0, S("abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 10, S("12345678901234567890"), 20, 1, S("abcdefghijklmnopqrst"));
TEST_CONSTEXPR_CXX20 bool test25()
     test(S("abcdefghijklmnopqrst"), 19, S("1234567890"), 1, 4, S("abcdefghijklmnopqrs2345t"));
     test(S("abcdefghijklmnopqrst"), 19, S("1234567890"), 1, 8, S("abcdefghijklmnopqrs23456789t"));
     test(S("abcdefghijklmnopqrst"), 19, S("1234567890"), 1, 9, S("abcdefghijklmnopqrs234567890t"));
     test(S("abcdefghijklmnopqrst"), 19, S("1234567890"), 1, 10, S("abcdefghijklmnopqrs234567890t"));
     test(S("abcdefghijklmnopqrst"), 19, S("1234567890"), 5, 0, S("abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 19, S("1234567890"), 5, 1, S("abcdefghijklmnopqrs6t"));
     test(S("abcdefghijklmnopqrst"), 19, S("1234567890"), 5, 2, S("abcdefghijklmnopqrs67t"));
     test(S("abcdefghijklmnopqrst"), 19, S("1234567890"), 5, 4, S("abcdefghijklmnopqrs6789t"));
+
+    return true;
 }
 
 template <class S>
-void test26()
+TEST_CONSTEXPR_CXX20 bool test26()
 {
     test(S("abcdefghijklmnopqrst"), 19, S("1234567890"), 5, 5, S("abcdefghijklmnopqrs67890t"));
     test(S("abcdefghijklmnopqrst"), 19, S("1234567890"), 5, 6, S("abcdefghijklmnopqrs67890t"));
     test(S("abcdefghijklmnopqrst"), 19, S("1234567890"), 9, 0, S("abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 19, S("1234567890"), 9, 1, S("abcdefghijklmnopqrs0t"));
     test(S("abcdefghijklmnopqrst"), 19, S("1234567890"), 9, 2, S("abcdefghijklmnopqrs0t"));
     test(S("abcdefghijklmnopqrst"), 19, S("1234567890"), 10, 0, S("abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 19, S("1234567890"), 10, 1, S("abcdefghijklmnopqrst"));
TEST_CONSTEXPR_CXX20 bool test26()
     test(S("abcdefghijklmnopqrst"), 20, S("12345"), 1, 1, S("abcdefghijklmnopqrst2"));
     test(S("abcdefghijklmnopqrst"), 20, S("12345"), 1, 2, S("abcdefghijklmnopqrst23"));
     test(S("abcdefghijklmnopqrst"), 20, S("12345"), 1, 3, S("abcdefghijklmnopqrst234"));
     test(S("abcdefghijklmnopqrst"), 20, S("12345"), 1, 4, S("abcdefghijklmnopqrst2345"));
     test(S("abcdefghijklmnopqrst"), 20, S("12345"), 1, 5, S("abcdefghijklmnopqrst2345"));
     test(S("abcdefghijklmnopqrst"), 20, S("12345"), 2, 0, S("abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 20, S("12345"), 2, 1, S("abcdefghijklmnopqrst3"));
     test(S("abcdefghijklmnopqrst"), 20, S("12345"), 2, 2, S("abcdefghijklmnopqrst34"));
+
+    return true;
 }
 
 template <class S>
-void test27()
+TEST_CONSTEXPR_CXX20 bool test27()
 {
     test(S("abcdefghijklmnopqrst"), 20, S("12345"), 2, 3, S("abcdefghijklmnopqrst345"));
     test(S("abcdefghijklmnopqrst"), 20, S("12345"), 2, 4, S("abcdefghijklmnopqrst345"));
     test(S("abcdefghijklmnopqrst"), 20, S("12345"), 4, 0, S("abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 20, S("12345"), 4, 1, S("abcdefghijklmnopqrst5"));
     test(S("abcdefghijklmnopqrst"), 20, S("12345"), 4, 2, S("abcdefghijklmnopqrst5"));
     test(S("abcdefghijklmnopqrst"), 20, S("12345"), 5, 0, S("abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 20, S("12345"), 5, 1, S("abcdefghijklmnopqrst"));
TEST_CONSTEXPR_CXX20 bool test27()
     test(S("abcdefghijklmnopqrst"), 20, S("12345678901234567890"), 1, 19, S("abcdefghijklmnopqrst2345678901234567890"));
     test(S("abcdefghijklmnopqrst"), 20, S("12345678901234567890"), 1, 20, S("abcdefghijklmnopqrst2345678901234567890"));
     test(S("abcdefghijklmnopqrst"), 20, S("12345678901234567890"), 10, 0, S("abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 20, S("12345678901234567890"), 10, 1, S("abcdefghijklmnopqrst1"));
     test(S("abcdefghijklmnopqrst"), 20, S("12345678901234567890"), 10, 5, S("abcdefghijklmnopqrst12345"));
     test(S("abcdefghijklmnopqrst"), 20, S("12345678901234567890"), 10, 9, S("abcdefghijklmnopqrst123456789"));
     test(S("abcdefghijklmnopqrst"), 20, S("12345678901234567890"), 10, 10, S("abcdefghijklmnopqrst1234567890"));
     test(S("abcdefghijklmnopqrst"), 20, S("12345678901234567890"), 10, 11, S("abcdefghijklmnopqrst1234567890"));
+
+    return true;
 }
 
 template <class S>
-void test28()
+TEST_CONSTEXPR_CXX20 bool test28()
 {
     test(S("abcdefghijklmnopqrst"), 20, S("12345678901234567890"), 19, 0, S("abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 20, S("12345678901234567890"), 19, 1, S("abcdefghijklmnopqrst0"));
     test(S("abcdefghijklmnopqrst"), 20, S("12345678901234567890"), 19, 2, S("abcdefghijklmnopqrst0"));
     test(S("abcdefghijklmnopqrst"), 20, S("12345678901234567890"), 20, 0, S("abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 20, S("12345678901234567890"), 20, 1, S("abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 20, S("12345678901234567890"), 21, 0, S("can't happen"));
     test(S("abcdefghijklmnopqrst"), 21, S(""), 0, 0, S("can't happen"));
TEST_CONSTEXPR_CXX20 bool test28()
     test(S("abcdefghijklmnopqrst"), 21, S("1234567890"), 1, 9, S("can't happen"));
     test(S("abcdefghijklmnopqrst"), 21, S("1234567890"), 1, 10, S("can't happen"));
     test(S("abcdefghijklmnopqrst"), 21, S("1234567890"), 5, 0, S("can't happen"));
     test(S("abcdefghijklmnopqrst"), 21, S("1234567890"), 5, 1, S("can't happen"));
     test(S("abcdefghijklmnopqrst"), 21, S("1234567890"), 5, 2, S("can't happen"));
     test(S("abcdefghijklmnopqrst"), 21, S("1234567890"), 5, 4, S("can't happen"));
     test(S("abcdefghijklmnopqrst"), 21, S("1234567890"), 5, 5, S("can't happen"));
     test(S("abcdefghijklmnopqrst"), 21, S("1234567890"), 5, 6, S("can't happen"));
+
+    return true;
 }
 
 template <class S>
-void test29()
+TEST_CONSTEXPR_CXX20 bool 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"));
     test(S("abcdefghijklmnopqrst"), 21, S("1234567890"), 9, 2, S("can't happen"));
     test(S("abcdefghijklmnopqrst"), 21, S("1234567890"), 10, 0, S("can't happen"));
     test(S("abcdefghijklmnopqrst"), 21, S("1234567890"), 10, 1, S("can't happen"));
     test(S("abcdefghijklmnopqrst"), 21, S("1234567890"), 11, 0, S("can't happen"));
     test(S("abcdefghijklmnopqrst"), 21, S("12345678901234567890"), 0, 0, S("can't happen"));
TEST_CONSTEXPR_CXX20 bool test29()
     test(S("abcdefghijklmnopqrst"), 21, S("12345678901234567890"), 10, 10, S("can't happen"));
     test(S("abcdefghijklmnopqrst"), 21, S("12345678901234567890"), 10, 11, S("can't happen"));
     test(S("abcdefghijklmnopqrst"), 21, S("12345678901234567890"), 19, 0, S("can't happen"));
     test(S("abcdefghijklmnopqrst"), 21, S("12345678901234567890"), 19, 1, S("can't happen"));
     test(S("abcdefghijklmnopqrst"), 21, S("12345678901234567890"), 19, 2, S("can't happen"));
     test(S("abcdefghijklmnopqrst"), 21, S("12345678901234567890"), 20, 0, S("can't happen"));
     test(S("abcdefghijklmnopqrst"), 21, S("12345678901234567890"), 20, 1, S("can't happen"));
     test(S("abcdefghijklmnopqrst"), 21, S("12345678901234567890"), 21, 0, S("can't happen"));
+
+    return true;
 }
 
 template <class S>
-void test30()
+TEST_CONSTEXPR_CXX20 bool test30()
 {
     test_npos(S(""), 0, S("12345678901234567890"),  0, S("12345678901234567890"));
     test_npos(S(""), 0, S("12345678901234567890"),  1, S( "2345678901234567890"));
     test_npos(S(""), 0, S("12345678901234567890"),  2, S(  "345678901234567890"));
     test_npos(S(""), 0, S("12345678901234567890"),  3, S(   "45678901234567890"));
     test_npos(S(""), 0, S("12345678901234567890"),  5, S(     "678901234567890"));
     test_npos(S(""), 0, S("12345678901234567890"), 10, S(          "1234567890"));
     test_npos(S(""), 0, S("12345678901234567890"), 21, S("can't happen"));
     test_npos(S("abcdefghijklmnopqrst"), 10, S("12345"), 0, S("abcdefghij12345klmnopqrst"));
     test_npos(S("abcdefghijklmnopqrst"), 10, S("12345"), 1, S("abcdefghij2345klmnopqrst"));
     test_npos(S("abcdefghijklmnopqrst"), 10, S("12345"), 3, S("abcdefghij45klmnopqrst"));
     test_npos(S("abcdefghijklmnopqrst"), 10, S("12345"), 5, S("abcdefghijklmnopqrst"));
     test_npos(S("abcdefghijklmnopqrst"), 10, S("12345"), 6, S("can't happen"));
+
+    return true;
 }
 
-int main(int, char**)
-{
-    {
+int main(int, char**) {
     typedef std::string S;
     test0<S>();
     test1<S>();
     test2<S>();
     test3<S>();
     test4<S>();
     test5<S>();
     test6<S>();
int main(int, char**) {
     test23<S>();
     test24<S>();
     test25<S>();
     test26<S>();
     test27<S>();
     test28<S>();
     test29<S>();
     test30<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>();
#if TEST_STD_VER >= 11
     test23<S>();
     test24<S>();
     test25<S>();
     test26<S>();
     test27<S>();
     test28<S>();
     test29<S>();
     test30<S>();
-    }
 #endif
 
+#if TEST_STD_VER > 17
+    {
+    typedef std::string S;
+    static_assert(test0<S>());
+    static_assert(test1<S>());
+    static_assert(test2<S>());
+    static_assert(test3<S>());
+    static_assert(test4<S>());
+    static_assert(test5<S>());
+    static_assert(test6<S>());
+    static_assert(test7<S>());
+    static_assert(test8<S>());
+    static_assert(test9<S>());
+    static_assert(test10<S>());
+    static_assert(test11<S>());
+    static_assert(test12<S>());
+    static_assert(test13<S>());
+    static_assert(test14<S>());
+    static_assert(test15<S>());
+    static_assert(test16<S>());
+    static_assert(test17<S>());
+    static_assert(test18<S>());
+    static_assert(test19<S>());
+    static_assert(test20<S>());
+    static_assert(test21<S>());
+    static_assert(test22<S>());
+    static_assert(test23<S>());
+    static_assert(test24<S>());
+    static_assert(test25<S>());
+    static_assert(test26<S>());
+    static_assert(test27<S>());
+    static_assert(test28<S>());
+    static_assert(test29<S>());
+    static_assert(test30<S>());
+  }
+  {
+    typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
+    static_assert(test0<S>());
+    static_assert(test1<S>());
+    static_assert(test2<S>());
+    static_assert(test3<S>());
+    static_assert(test4<S>());
+    static_assert(test5<S>());
+    static_assert(test6<S>());
+    static_assert(test7<S>());
+    static_assert(test8<S>());
+    static_assert(test9<S>());
+    static_assert(test10<S>());
+    static_assert(test11<S>());
+    static_assert(test12<S>());
+    static_assert(test13<S>());
+    static_assert(test14<S>());
+    static_assert(test15<S>());
+    static_assert(test16<S>());
+    static_assert(test17<S>());
+    static_assert(test18<S>());
+    static_assert(test19<S>());
+    static_assert(test20<S>());
+    static_assert(test21<S>());
+    static_assert(test22<S>());
+    static_assert(test23<S>());
+    static_assert(test24<S>());
+    static_assert(test25<S>());
+    static_assert(test26<S>());
+    static_assert(test27<S>());
+    static_assert(test28<S>());
+    static_assert(test29<S>());
+    static_assert(test30<S>());
+  }
+#endif
+
   return 0;
 }

libcxx/test/std/strings/basic.string/string.modifiers/string_replace/iter_iter_iter_iter.pass.cpp

 #include <iterator>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
 #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();
     typename S::const_iterator first = s.begin() + pos1;
     typename S::const_iterator last = s.begin() + pos1 + n1;
     typename S::size_type xlen = last - first;
     s.replace(first, last, f, l);
     LIBCPP_ASSERT(s.__invariants());
     assert(s == expected);
     typename S::size_type rlen = std::distance(f, l);
     assert(s.size() == old_size - xlen + rlen);
 }
 
 #ifndef TEST_HAS_NO_EXCEPTIONS
 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;
     typename S::const_iterator last = s.begin() + pos1 + n1;
 
     S original = s;
     typename S::iterator begin = s.begin();
     typename S::iterator end = s.end();
 
     try {
         s.replace(first, last, f, l);
         assert(false);
     } catch (...) {}
 
     // Part of "no effects" is that iterators and pointers
     // into the string must not have been invalidated.
     LIBCPP_ASSERT(s.__invariants());
     assert(s == original);
     assert(s.begin() == begin);
     assert(s.end() == end);
 }
 #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(""));
     test(S(""), 0, 0, str, str+1, S("1"));
     test(S(""), 0, 0, str, str+2, S("12"));
     test(S(""), 0, 0, str, str+4, S("1234"));
     test(S(""), 0, 0, str, str+5, S("12345"));
     test(S(""), 0, 0, str, str+0, S(""));
TEST_CONSTEXPR_CXX20 void test0()
     test(S("abcde"), 0, 5, str, str+20, S("12345678901234567890"));
     test(S("abcde"), 1, 0, str, str+0, S("abcde"));
     test(S("abcde"), 1, 0, str, str+0, S("abcde"));
     test(S("abcde"), 1, 0, str, str+1, S("a1bcde"));
     test(S("abcde"), 1, 0, str, str+2, S("a12bcde"));
 }
 
 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"));
     test(S("abcde"), 1, 0, str, str+0, S("abcde"));
     test(S("abcde"), 1, 0, str, str+1, S("a1bcde"));
     test(S("abcde"), 1, 0, str, str+5, S("a12345bcde"));
     test(S("abcde"), 1, 0, str, str+9, S("a123456789bcde"));
     test(S("abcde"), 1, 0, str, str+10, S("a1234567890bcde"));
TEST_CONSTEXPR_CXX20 void test1()
     test(S("abcde"), 2, 1, str, str+2, S("ab12de"));
     test(S("abcde"), 2, 1, str, str+4, S("ab1234de"));
     test(S("abcde"), 2, 1, str, str+5, S("ab12345de"));
     test(S("abcde"), 2, 1, str, str+0, S("abde"));
     test(S("abcde"), 2, 1, str, str+1, S("ab1de"));
 }
 
 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"));
     test(S("abcde"), 2, 1, str, str+10, S("ab1234567890de"));
     test(S("abcde"), 2, 1, str, str+0, S("abde"));
     test(S("abcde"), 2, 1, str, str+1, S("ab1de"));
     test(S("abcde"), 2, 1, str, str+10, S("ab1234567890de"));
     test(S("abcde"), 2, 1, str, str+19, S("ab1234567890123456789de"));
TEST_CONSTEXPR_CXX20 void test2()
     test(S("abcdefghij"), 0, 0, str, str+1, S("1abcdefghij"));
     test(S("abcdefghij"), 0, 0, str, str+5, S("12345abcdefghij"));
     test(S("abcdefghij"), 0, 0, str, str+9, S("123456789abcdefghij"));
     test(S("abcdefghij"), 0, 0, str, str+10, S("1234567890abcdefghij"));
     test(S("abcdefghij"), 0, 0, str, str+0, S("abcdefghij"));
 }
 
 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"));
     test(S("abcdefghij"), 0, 0, str, str+19, S("1234567890123456789abcdefghij"));
     test(S("abcdefghij"), 0, 0, str, str+20, S("12345678901234567890abcdefghij"));
     test(S("abcdefghij"), 0, 1, str, str+0, S("bcdefghij"));
     test(S("abcdefghij"), 0, 1, str, str+0, S("bcdefghij"));
     test(S("abcdefghij"), 0, 1, str, str+1, S("1bcdefghij"));
TEST_CONSTEXPR_CXX20 void test3()
     test(S("abcdefghij"), 1, 1, str, str+0, S("acdefghij"));
     test(S("abcdefghij"), 1, 1, str, str+1, S("a1cdefghij"));
     test(S("abcdefghij"), 1, 1, str, str+10, S("a1234567890cdefghij"));
     test(S("abcdefghij"), 1, 1, str, str+19, S("a1234567890123456789cdefghij"));
     test(S("abcdefghij"), 1, 1, str, str+20, S("a12345678901234567890cdefghij"));
 }
 
 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"));
     test(S("abcdefghij"), 1, 4, str, str+1, S("a1fghij"));
     test(S("abcdefghij"), 1, 4, str, str+2, S("a12fghij"));
     test(S("abcdefghij"), 1, 4, str, str+4, S("a1234fghij"));
     test(S("abcdefghij"), 1, 4, str, str+5, S("a12345fghij"));
     test(S("abcdefghij"), 1, 4, str, str+0, S("afghij"));
TEST_CONSTEXPR_CXX20 void test4()
     test(S("abcdefghij"), 5, 2, str, str+20, S("abcde12345678901234567890hij"));
     test(S("abcdefghij"), 5, 4, str, str+0, S("abcdej"));
     test(S("abcdefghij"), 5, 4, str, str+0, S("abcdej"));
     test(S("abcdefghij"), 5, 4, str, str+1, S("abcde1j"));
     test(S("abcdefghij"), 5, 4, str, str+2, S("abcde12j"));
 }
 
 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"));
     test(S("abcdefghij"), 5, 4, str, str+0, S("abcdej"));
     test(S("abcdefghij"), 5, 4, str, str+1, S("abcde1j"));
     test(S("abcdefghij"), 5, 4, str, str+5, S("abcde12345j"));
     test(S("abcdefghij"), 5, 4, str, str+9, S("abcde123456789j"));
     test(S("abcdefghij"), 5, 4, str, str+10, S("abcde1234567890j"));
TEST_CONSTEXPR_CXX20 void test5()
     test(S("abcdefghijklmnopqrst"), 0, 1, str, str+2, S("12bcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 0, 1, str, str+4, S("1234bcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 0, 1, str, str+5, S("12345bcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 0, 1, str, str+0, S("bcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 0, 1, str, str+1, S("1bcdefghijklmnopqrst"));
 }
 
 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"));
     test(S("abcdefghijklmnopqrst"), 0, 1, str, str+10, S("1234567890bcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 0, 1, str, str+0, S("bcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 0, 1, str, str+1, S("1bcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 0, 1, str, str+10, S("1234567890bcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 0, 1, str, str+19, S("1234567890123456789bcdefghijklmnopqrst"));
TEST_CONSTEXPR_CXX20 void test6()
     test(S("abcdefghijklmnopqrst"), 1, 9, str, str+1, S("a1klmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 1, 9, str, str+5, S("a12345klmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 1, 9, str, str+9, S("a123456789klmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 1, 9, str, str+10, S("a1234567890klmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 1, 9, str, str+0, S("aklmnopqrst"));
 }
 
 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"));
     test(S("abcdefghijklmnopqrst"), 1, 9, str, str+19, S("a1234567890123456789klmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 1, 9, str, str+20, S("a12345678901234567890klmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 1, 18, str, str+0, S("at"));
     test(S("abcdefghijklmnopqrst"), 1, 18, str, str+0, S("at"));
     test(S("abcdefghijklmnopqrst"), 1, 18, str, str+1, S("a1t"));
TEST_CONSTEXPR_CXX20 void test7()
     test(S("abcdefghijklmnopqrst"), 10, 9, str, str+0, S("abcdefghijt"));
     test(S("abcdefghijklmnopqrst"), 10, 9, str, str+1, S("abcdefghij1t"));
     test(S("abcdefghijklmnopqrst"), 10, 9, str, str+10, S("abcdefghij1234567890t"));
     test(S("abcdefghijklmnopqrst"), 10, 9, str, str+19, S("abcdefghij1234567890123456789t"));
     test(S("abcdefghijklmnopqrst"), 10, 9, str, str+20, S("abcdefghij12345678901234567890t"));
 }
 
 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"));
     test(S("abcdefghijklmnopqrst"), 10, 10, str, str+1, S("abcdefghij1"));
     test(S("abcdefghijklmnopqrst"), 10, 10, str, str+2, S("abcdefghij12"));
     test(S("abcdefghijklmnopqrst"), 10, 10, str, str+4, S("abcdefghij1234"));
     test(S("abcdefghijklmnopqrst"), 10, 10, str, str+5, S("abcdefghij12345"));
     test(S("abcdefghijklmnopqrst"), 10, 10, str, str+0, S("abcdefghij"));
TEST_CONSTEXPR_CXX20 void test8()
     test(S("abcdefghijklmnopqrst"), 20, 0, str, str+10, S("abcdefghijklmnopqrst1234567890"));
     test(S("abcdefghijklmnopqrst"), 20, 0, str, str+0, S("abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 20, 0, str, str+1, S("abcdefghijklmnopqrst1"));
     test(S("abcdefghijklmnopqrst"), 20, 0, str, str+10, S("abcdefghijklmnopqrst1234567890"));
     test(S("abcdefghijklmnopqrst"), 20, 0, str, str+19, S("abcdefghijklmnopqrst1234567890123456789"));
     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;
     test0<S>();
     test1<S>();
     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;
     const char* s = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
     test_exceptions(S("abcdefghijklmnopqrst"), 10, 5, IIter(TIter(s, s+10, 4, TIter::TAIncrement)), IIter());
     test_exceptions(S("abcdefghijklmnopqrst"), 10, 5, IIter(TIter(s, s+10, 5, TIter::TADereference)), IIter());
     test_exceptions(S("abcdefghijklmnopqrst"), 10, 5, IIter(TIter(s, s+10, 6, TIter::TAComparison)), IIter());
 
#endif
     uint8_t        p[] = "EFGH";
 
     S s;
     s.replace(s.begin(), s.end(), pc, pc + 4);
     assert(s == "ABCD");
 
     s.clear();
     s.replace(s.begin(), s.end(), p, p + 4);
     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;
 }

libcxx/test/std/strings/basic.string/string.modifiers/string_replace/iter_iter_pointer_size.pass.cpp

 #include <string>
 #include <algorithm>
 #include <cassert>
 
 #include "test_macros.h"
 #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)
 {
     typename S::size_type old_size = s.size();
     typename S::const_iterator first = s.begin() + pos1;
     typename S::const_iterator last = s.begin() + pos1 + n1;
     typename S::size_type xlen = last - first;
     s.replace(first, last, str, n2);
     LIBCPP_ASSERT(s.__invariants());
     assert(s == expected);
     typename S::size_type rlen = n2;
     assert(s.size() == old_size - xlen + rlen);
 }
 
 template <class S>
-void test0()
+TEST_CONSTEXPR_CXX20 void test0()
 {
     test(S(""), 0, 0, "", 0, S(""));
     test(S(""), 0, 0, "12345", 0, S(""));
     test(S(""), 0, 0, "12345", 1, S("1"));
     test(S(""), 0, 0, "12345", 2, S("12"));
     test(S(""), 0, 0, "12345", 4, S("1234"));
     test(S(""), 0, 0, "12345", 5, S("12345"));
     test(S(""), 0, 0, "1234567890", 0, S(""));
TEST_CONSTEXPR_CXX20 void test0()
     test(S("abcde"), 0, 5, "12345678901234567890", 20, S("12345678901234567890"));
     test(S("abcde"), 1, 0, "", 0, S("abcde"));
     test(S("abcde"), 1, 0, "12345", 0, S("abcde"));
     test(S("abcde"), 1, 0, "12345", 1, S("a1bcde"));
     test(S("abcde"), 1, 0, "12345", 2, S("a12bcde"));
 }
 
 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"));
     test(S("abcde"), 1, 0, "1234567890", 0, S("abcde"));
     test(S("abcde"), 1, 0, "1234567890", 1, S("a1bcde"));
     test(S("abcde"), 1, 0, "1234567890", 5, S("a12345bcde"));
     test(S("abcde"), 1, 0, "1234567890", 9, S("a123456789bcde"));
     test(S("abcde"), 1, 0, "1234567890", 10, S("a1234567890bcde"));
TEST_CONSTEXPR_CXX20 void test1()
     test(S("abcde"), 2, 1, "12345", 2, S("ab12de"));
     test(S("abcde"), 2, 1, "12345", 4, S("ab1234de"));
     test(S("abcde"), 2, 1, "12345", 5, S("ab12345de"));
     test(S("abcde"), 2, 1, "1234567890", 0, S("abde"));
     test(S("abcde"), 2, 1, "1234567890", 1, S("ab1de"));
 }
 
 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"));
     test(S("abcde"), 2, 1, "1234567890", 10, S("ab1234567890de"));
     test(S("abcde"), 2, 1, "12345678901234567890", 0, S("abde"));
     test(S("abcde"), 2, 1, "12345678901234567890", 1, S("ab1de"));
     test(S("abcde"), 2, 1, "12345678901234567890", 10, S("ab1234567890de"));
     test(S("abcde"), 2, 1, "12345678901234567890", 19, S("ab1234567890123456789de"));
TEST_CONSTEXPR_CXX20 void test2()
     test(S("abcdefghij"), 0, 0, "1234567890", 1, S("1abcdefghij"));
     test(S("abcdefghij"), 0, 0, "1234567890", 5, S("12345abcdefghij"));
     test(S("abcdefghij"), 0, 0, "1234567890", 9, S("123456789abcdefghij"));
     test(S("abcdefghij"), 0, 0, "1234567890", 10, S("1234567890abcdefghij"));
     test(S("abcdefghij"), 0, 0, "12345678901234567890", 0, S("abcdefghij"));
 }
 
 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"));
     test(S("abcdefghij"), 0, 0, "12345678901234567890", 19, S("1234567890123456789abcdefghij"));
     test(S("abcdefghij"), 0, 0, "12345678901234567890", 20, S("12345678901234567890abcdefghij"));
     test(S("abcdefghij"), 0, 1, "", 0, S("bcdefghij"));
     test(S("abcdefghij"), 0, 1, "12345", 0, S("bcdefghij"));
     test(S("abcdefghij"), 0, 1, "12345", 1, S("1bcdefghij"));
TEST_CONSTEXPR_CXX20 void test3()
     test(S("abcdefghij"), 1, 1, "12345678901234567890", 0, S("acdefghij"));
     test(S("abcdefghij"), 1, 1, "12345678901234567890", 1, S("a1cdefghij"));
     test(S("abcdefghij"), 1, 1, "12345678901234567890", 10, S("a1234567890cdefghij"));
     test(S("abcdefghij"), 1, 1, "12345678901234567890", 19, S("a1234567890123456789cdefghij"));
     test(S("abcdefghij"), 1, 1, "12345678901234567890", 20, S("a12345678901234567890cdefghij"));
 }
 
 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"));
     test(S("abcdefghij"), 1, 4, "12345", 1, S("a1fghij"));
     test(S("abcdefghij"), 1, 4, "12345", 2, S("a12fghij"));
     test(S("abcdefghij"), 1, 4, "12345", 4, S("a1234fghij"));
     test(S("abcdefghij"), 1, 4, "12345", 5, S("a12345fghij"));
     test(S("abcdefghij"), 1, 4, "1234567890", 0, S("afghij"));
TEST_CONSTEXPR_CXX20 void test4()
     test(S("abcdefghij"), 5, 2, "12345678901234567890", 20, S("abcde12345678901234567890hij"));
     test(S("abcdefghij"), 5, 4, "", 0, S("abcdej"));
     test(S("abcdefghij"), 5, 4, "12345", 0, S("abcdej"));
     test(S("abcdefghij"), 5, 4, "12345", 1, S("abcde1j"));
     test(S("abcdefghij"), 5, 4, "12345", 2, S("abcde12j"));
 }
 
 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"));
     test(S("abcdefghij"), 5, 4, "1234567890", 0, S("abcdej"));
     test(S("abcdefghij"), 5, 4, "1234567890", 1, S("abcde1j"));
     test(S("abcdefghij"), 5, 4, "1234567890", 5, S("abcde12345j"));
     test(S("abcdefghij"), 5, 4, "1234567890", 9, S("abcde123456789j"));
     test(S("abcdefghij"), 5, 4, "1234567890", 10, S("abcde1234567890j"));
TEST_CONSTEXPR_CXX20 void test5()
     test(S("abcdefghijklmnopqrst"), 0, 1, "12345", 2, S("12bcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 0, 1, "12345", 4, S("1234bcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 0, 1, "12345", 5, S("12345bcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 0, 1, "1234567890", 0, S("bcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 0, 1, "1234567890", 1, S("1bcdefghijklmnopqrst"));
 }
 
 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"));
     test(S("abcdefghijklmnopqrst"), 0, 1, "1234567890", 10, S("1234567890bcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 0, 1, "12345678901234567890", 0, S("bcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 0, 1, "12345678901234567890", 1, S("1bcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 0, 1, "12345678901234567890", 10, S("1234567890bcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 0, 1, "12345678901234567890", 19, S("1234567890123456789bcdefghijklmnopqrst"));
TEST_CONSTEXPR_CXX20 void test6()
     test(S("abcdefghijklmnopqrst"), 1, 9, "1234567890", 1, S("a1klmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 1, 9, "1234567890", 5, S("a12345klmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 1, 9, "1234567890", 9, S("a123456789klmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 1, 9, "1234567890", 10, S("a1234567890klmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 1, 9, "12345678901234567890", 0, S("aklmnopqrst"));
 }
 
 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"));
     test(S("abcdefghijklmnopqrst"), 1, 9, "12345678901234567890", 19, S("a1234567890123456789klmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 1, 9, "12345678901234567890", 20, S("a12345678901234567890klmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 1, 18, "", 0, S("at"));
     test(S("abcdefghijklmnopqrst"), 1, 18, "12345", 0, S("at"));
     test(S("abcdefghijklmnopqrst"), 1, 18, "12345", 1, S("a1t"));
TEST_CONSTEXPR_CXX20 void test7()
     test(S("abcdefghijklmnopqrst"), 10, 9, "12345678901234567890", 0, S("abcdefghijt"));
     test(S("abcdefghijklmnopqrst"), 10, 9, "12345678901234567890", 1, S("abcdefghij1t"));
     test(S("abcdefghijklmnopqrst"), 10, 9, "12345678901234567890", 10, S("abcdefghij1234567890t"));
     test(S("abcdefghijklmnopqrst"), 10, 9, "12345678901234567890", 19, S("abcdefghij1234567890123456789t"));
     test(S("abcdefghijklmnopqrst"), 10, 9, "12345678901234567890", 20, S("abcdefghij12345678901234567890t"));
 }
 
 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"));
     test(S("abcdefghijklmnopqrst"), 10, 10, "12345", 1, S("abcdefghij1"));
     test(S("abcdefghijklmnopqrst"), 10, 10, "12345", 2, S("abcdefghij12"));
     test(S("abcdefghijklmnopqrst"), 10, 10, "12345", 4, S("abcdefghij1234"));
     test(S("abcdefghijklmnopqrst"), 10, 10, "12345", 5, S("abcdefghij12345"));
     test(S("abcdefghijklmnopqrst"), 10, 10, "1234567890", 0, S("abcdefghij"));
TEST_CONSTEXPR_CXX20 void test8()
     test(S("abcdefghijklmnopqrst"), 20, 0, "1234567890", 1, S("abcdefghijklmnopqrst1"));
     test(S("abcdefghijklmnopqrst"), 20, 0, "1234567890", 5, S("abcdefghijklmnopqrst12345"));
     test(S("abcdefghijklmnopqrst"), 20, 0, "1234567890", 9, S("abcdefghijklmnopqrst123456789"));
     test(S("abcdefghijklmnopqrst"), 20, 0, "1234567890", 10, S("abcdefghijklmnopqrst1234567890"));
     test(S("abcdefghijklmnopqrst"), 20, 0, "12345678901234567890", 0, S("abcdefghijklmnopqrst"));
     test(S("abcdefghijklmnopqrst"), 20, 0, "12345678901234567890", 1, S("abcdefghijklmnopqrst1"));
     test(S("abcdefghijklmnopqrst"), 20, 0, "12345678901234567890", 10, S("abcdefghijklmnopqrst1234567890"));
     test(S("abcdefghijklmnopqrst"), 20, 0, "12345678901234567890", 19, S("abcdefghijklmnopqrst1234567890123456789"));
     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;
     test0<S>();
     test1<S>();
     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/";
     S s_long  = "Lorem ipsum dolor sit amet, consectetur/";
 
     s_short.replace(s_short.begin(), s_short.begin(), s_short.data(), s_short.size());
     assert(s_short == "123/123/");
     s_short.replace(s_short.begin(), s_short.begin(), s_short.data(), s_short.size());
     assert(s_short == "123/123/123/123/");
     s_short.replace(s_short.begin(), s_short.begin(), s_short.data(), s_short.size());
     assert(s_short == "123/123/123/123/123/123/123/123/");
 
     s_long.replace(s_long.begin(), s_long.begin(), s_long.data(), s_long.size());
     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;
 }

libcxx/test/std/strings/basic.string/string.ops/string_compare/size_size_T_size_size.pass.cpp

 #include <string>
 #include <stdexcept>
 #include <cassert>
 
 #include "min_allocator.h"
 
 #include "test_macros.h"
 
-int sign(int x)
+TEST_CONSTEXPR_CXX20 int sign(int x)
 {
     if (x == 0)
         return 0;
     if (x < 0)
         return -1;
     return 1;
 }
 
 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)
 {
     static_assert((!std::is_same<S, SV>::value), "");
     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
         {
             TEST_IGNORE_NODISCARD s.compare(pos1, n1, sv, pos2, n2);
             assert(false);
         }
         catch (const std::out_of_range&)
         {
             assert(pos1 > s.size() || pos2 > sv.size());
         }
     }
 #endif
 }
 
 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)
 {
     static_assert((!std::is_same<S, SV>::value), "");
     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
         {
             TEST_IGNORE_NODISCARD s.compare(pos1, n1, sv, pos2);
             assert(false);
         }
         catch (const std::out_of_range&)
         {
             assert(pos1 > s.size() || pos2 > sv.size());
         }
     }
 #endif
 }
 
 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);
     test(S(""), 0, 0, SV(""), 1, 0, 0);
     test(S(""), 0, 0, SV("abcde"), 0, 0, 0);
     test(S(""), 0, 0, SV("abcde"), 0, 1, -1);
     test(S(""), 0, 0, SV("abcde"), 0, 2, -2);
     test(S(""), 0, 0, SV("abcde"), 0, 4, -4);
TEST_CONSTEXPR_CXX20 void test0()
     test(S(""), 0, 1, SV("abcde"), 4, 1, -1);
     test(S(""), 0, 1, SV("abcde"), 4, 2, -1);
     test(S(""), 0, 1, SV("abcde"), 5, 0, 0);
     test(S(""), 0, 1, SV("abcde"), 5, 1, 0);
     test(S(""), 0, 1, SV("abcde"), 6, 0, 0);
 }
 
 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);
     test(S(""), 0, 1, SV("abcdefghij"), 0, 5, -5);
     test(S(""), 0, 1, SV("abcdefghij"), 0, 9, -9);
     test(S(""), 0, 1, SV("abcdefghij"), 0, 10, -10);
     test(S(""), 0, 1, SV("abcdefghij"), 0, 11, -10);
     test(S(""), 0, 1, SV("abcdefghij"), 1, 0, 0);
TEST_CONSTEXPR_CXX20 void test1()
     test(S(""), 1, 0, SV("abcdefghij"), 10, 0, 0);
     test(S(""), 1, 0, SV("abcdefghij"), 10, 1, 0);
     test(S(""), 1, 0, SV("abcdefghij"), 11, 0, 0);
     test(S(""), 1, 0, SV("abcdefghijklmnopqrst"), 0, 0, 0);
     test(S(""), 1, 0, SV("abcdefghijklmnopqrst"), 0, 1, 0);
 }
 
 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);
     test(S(""), 1, 0, SV("abcdefghijklmnopqrst"), 0, 20, 0);
     test(S(""), 1, 0, SV("abcdefghijklmnopqrst"), 0, 21, 0);
     test(S(""), 1, 0, SV("abcdefghijklmnopqrst"), 1, 0, 0);
     test(S(""), 1, 0, SV("abcdefghijklmnopqrst"), 1, 1, 0);
     test(S(""), 1, 0, SV("abcdefghijklmnopqrst"), 1, 9, 0);
TEST_CONSTEXPR_CXX20 void test2()
     test(S("abcde"), 0, 0, SV("abcdefghijklmnopqrst"), 21, 0, 0);
     test(S("abcde"), 0, 1, SV(""), 0, 0, 1);
     test(S("abcde"), 0, 1, SV(""), 0, 1, 1);
     test(S("abcde"), 0, 1, SV(""), 1, 0, 0);
     test(S("abcde"), 0, 1, SV("abcde"), 0, 0, 1);
 }
 
 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);
     test(S("abcde"), 0, 1, SV("abcde"), 0, 4, -3);
     test(S("abcde"), 0, 1, SV("abcde"), 0, 5, -4);
     test(S("abcde"), 0, 1, SV("abcde"), 0, 6, -4);
     test(S("abcde"), 0, 1, SV("abcde"), 1, 0, 1);
     test(S("abcde"), 0, 1, SV("abcde"), 1, 1, -1);
TEST_CONSTEXPR_CXX20 void test3()
     test(S("abcde"), 0, 2, SV("abcde"), 6, 0, 0);
     test(S("abcde"), 0, 2, SV("abcdefghij"), 0, 0, 2);
     test(S("abcde"), 0, 2, SV("abcdefghij"), 0, 1, 1);
     test(S("abcde"), 0, 2, SV("abcdefghij"), 0, 5, -3);
     test(S("abcde"), 0, 2, SV("abcdefghij"), 0, 9, -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);
     test(S("abcde"), 0, 2, SV("abcdefghij"), 1, 0, 2);
     test(S("abcde"), 0, 2, SV("abcdefghij"), 1, 1, -1);
     test(S("abcde"), 0, 2, SV("abcdefghij"), 1, 4, -1);
     test(S("abcde"), 0, 2, SV("abcdefghij"), 1, 8, -1);
     test(S("abcde"), 0, 2, SV("abcdefghij"), 1, 9, -1);
TEST_CONSTEXPR_CXX20 void test4()
     test(S("abcde"), 0, 4, SV("abcdefghijklmnopqrst"), 0, 1, 3);
     test(S("abcde"), 0, 4, SV("abcdefghijklmnopqrst"), 0, 10, -6);
     test(S("abcde"), 0, 4, SV("abcdefghijklmnopqrst"), 0, 19, -15);
     test(S("abcde"), 0, 4, SV("abcdefghijklmnopqrst"), 0, 20, -16);
     test(S("abcde"), 0, 4, SV("abcdefghijklmnopqrst"), 0, 21, -16);
 }
 
 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);
     test(S("abcde"), 0, 4, SV("abcdefghijklmnopqrst"), 1, 9, -1);
     test(S("abcde"), 0, 4, SV("abcdefghijklmnopqrst"), 1, 18, -1);
     test(S("abcde"), 0, 4, SV("abcdefghijklmnopqrst"), 1, 19, -1);
     test(S("abcde"), 0, 4, SV("abcdefghijklmnopqrst"), 1, 20, -1);
     test(S("abcde"), 0, 4, SV("abcdefghijklmnopqrst"), 10, 0, 4);
TEST_CONSTEXPR_CXX20 void test5()
     test(S("abcde"), 0, 6, SV("abcde"), 0, 0, 5);
     test(S("abcde"), 0, 6, SV("abcde"), 0, 1, 4);
     test(S("abcde"), 0, 6, SV("abcde"), 0, 2, 3);
     test(S("abcde"), 0, 6, SV("abcde"), 0, 4, 1);
     test(S("abcde"), 0, 6, SV("abcde"), 0, 5, 0);
 }
 
 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);
     test(S("abcde"), 0, 6, SV("abcde"), 1, 1, -1);
     test(S("abcde"), 0, 6, SV("abcde"), 1, 2, -1);
     test(S("abcde"), 0, 6, SV("abcde"), 1, 3, -1);
     test(S("abcde"), 0, 6, SV("abcde"), 1, 4, -1);
     test(S("abcde"), 0, 6, SV("abcde"), 1, 5, -1);
TEST_CONSTEXPR_CXX20 void test6()
     test(S("abcde"), 1, 0, SV("abcdefghij"), 0, 9, -9);
     test(S("abcde"), 1, 0, SV("abcdefghij"), 0, 10, -10);
     test(S("abcde"), 1, 0, SV("abcdefghij"), 0, 11, -10);
     test(S("abcde"), 1, 0, SV("abcdefghij"), 1, 0, 0);
     test(S("abcde"), 1, 0, SV("abcdefghij"), 1, 1, -1);
 }
 
 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);
     test(S("abcde"), 1, 0, SV("abcdefghij"), 1, 9, -9);
     test(S("abcde"), 1, 0, SV("abcdefghij"), 1, 10, -9);
     test(S("abcde"), 1, 0, SV("abcdefghij"), 5, 0, 0);
     test(S("abcde"), 1, 0, SV("abcdefghij"), 5, 1, -1);
     test(S("abcde"), 1, 0, SV("abcdefghij"), 5, 2, -2);
TEST_CONSTEXPR_CXX20 void test7()
     test(S("abcde"), 1, 1, SV("abcdefghijklmnopqrst"), 0, 21, 1);
     test(S("abcde"), 1, 1, SV("abcdefghijklmnopqrst"), 1, 0, 1);
     test(S("abcde"), 1, 1, SV("abcdefghijklmnopqrst"), 1, 1, 0);
     test(S("abcde"), 1, 1, SV("abcdefghijklmnopqrst"), 1, 9, -8);
     test(S("abcde"), 1, 1, SV("abcdefghijklmnopqrst"), 1, 18, -17);
 }
 
 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);
     test(S("abcde"), 1, 1, SV("abcdefghijklmnopqrst"), 10, 0, 1);
     test(S("abcde"), 1, 1, SV("abcdefghijklmnopqrst"), 10, 1, -9);
     test(S("abcde"), 1, 1, SV("abcdefghijklmnopqrst"), 10, 5, -9);
     test(S("abcde"), 1, 1, SV("abcdefghijklmnopqrst"), 10, 9, -9);
     test(S("abcde"), 1, 1, SV("abcdefghijklmnopqrst"), 10, 10, -9);
TEST_CONSTEXPR_CXX20 void test8()
     test(S("abcde"), 1, 3, SV("abcde"), 0, 5, 1);
     test(S("abcde"), 1, 3, SV("abcde"), 0, 6, 1);
     test(S("abcde"), 1, 3, SV("abcde"), 1, 0, 3);
     test(S("abcde"), 1, 3, SV("abcde"), 1, 1, 2);
     test(S("abcde"), 1, 3, SV("abcde"), 1, 2, 1);
 }
 
 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);
     test(S("abcde"), 1, 3, SV("abcde"), 1, 5, -1);
     test(S("abcde"), 1, 3, SV("abcde"), 2, 0, 3);
     test(S("abcde"), 1, 3, SV("abcde"), 2, 1, -1);
     test(S("abcde"), 1, 3, SV("abcde"), 2, 2, -1);
     test(S("abcde"), 1, 3, SV("abcde"), 2, 3, -1);
TEST_CONSTEXPR_CXX20 void test9()
     test(S("abcde"), 1, 4, SV("abcdefghij"), 1, 1, 3);
     test(S("abcde"), 1, 4, SV("abcdefghij"), 1, 4, 0);
     test(S("abcde"), 1, 4, SV("abcdefghij"), 1, 8, -4);
     test(S("abcde"), 1, 4, SV("abcdefghij"), 1, 9, -5);
     test(S("abcde"), 1, 4, SV("abcdefghij"), 1, 10, -5);
 }
 
 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);
     test(S("abcde"), 1, 4, SV("abcdefghij"), 5, 2, -4);
     test(S("abcde"), 1, 4, SV("abcdefghij"), 5, 4, -4);
     test(S("abcde"), 1, 4, SV("abcdefghij"), 5, 5, -4);
     test(S("abcde"), 1, 4, SV("abcdefghij"), 5, 6, -4);
     test(S("abcde"), 1, 4, SV("abcdefghij"), 9, 0, 4);
TEST_CONSTEXPR_CXX20 void test10()
     test(S("abcde"), 1, 5, SV("abcdefghijklmnopqrst"), 1, 18, -14);
     test(S("abcde"), 1, 5, SV("abcdefghijklmnopqrst"), 1, 19, -15);
     test(S("abcde"), 1, 5, SV("abcdefghijklmnopqrst"), 1, 20, -15);
     test(S("abcde"), 1, 5, SV("abcdefghijklmnopqrst"), 10, 0, 4);
     test(S("abcde"), 1, 5, SV("abcdefghijklmnopqrst"), 10, 1, -9);
 }
 
 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);
     test(S("abcde"), 1, 5, SV("abcdefghijklmnopqrst"), 10, 10, -9);
     test(S("abcde"), 1, 5, SV("abcdefghijklmnopqrst"), 10, 11, -9);
     test(S("abcde"), 1, 5, SV("abcdefghijklmnopqrst"), 19, 0, 4);
     test(S("abcde"), 1, 5, SV("abcdefghijklmnopqrst"), 19, 1, -18);
     test(S("abcde"), 1, 5, SV("abcdefghijklmnopqrst"), 19, 2, -18);
TEST_CONSTEXPR_CXX20 void test11()
     test(S("abcde"), 2, 1, SV("abcde"), 1, 2, 1);
     test(S("abcde"), 2, 1, SV("abcde"), 1, 3, 1);
     test(S("abcde"), 2, 1, SV("abcde"), 1, 4, 1);
     test(S("abcde"), 2, 1, SV("abcde"), 1, 5, 1);
     test(S("abcde"), 2, 1, SV("abcde"), 2, 0, 1);
 }
 
 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);
     test(S("abcde"), 2, 1, SV("abcde"), 2, 3, -2);
     test(S("abcde"), 2, 1, SV("abcde"), 2, 4, -2);
     test(S("abcde"), 2, 1, SV("abcde"), 4, 0, 1);
     test(S("abcde"), 2, 1, SV("abcde"), 4, 1, -2);
     test(S("abcde"), 2, 1, SV("abcde"), 4, 2, -2);
TEST_CONSTEXPR_CXX20 void test12()
     test(S("abcde"), 2, 2, SV("abcdefghij"), 1, 10, 1);
     test(S("abcde"), 2, 2, SV("abcdefghij"), 5, 0, 2);
     test(S("abcde"), 2, 2, SV("abcdefghij"), 5, 1, -3);
     test(S("abcde"), 2, 2, SV("abcdefghij"), 5, 2, -3);
     test(S("abcde"), 2, 2, SV("abcdefghij"), 5, 4, -3);
 }
 
 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);
     test(S("abcde"), 2, 2, SV("abcdefghij"), 9, 0, 2);
     test(S("abcde"), 2, 2, SV("abcdefghij"), 9, 1, -7);
     test(S("abcde"), 2, 2, SV("abcdefghij"), 9, 2, -7);
     test(S("abcde"), 2, 2, SV("abcdefghij"), 10, 0, 2);
     test(S("abcde"), 2, 2, SV("abcdefghij"), 10, 1, 2);
TEST_CONSTEXPR_CXX20 void test13()
     test(S("abcde"), 2, 3, SV("abcdefghijklmnopqrst"), 10, 1, -8);
     test(S("abcde"), 2, 3, SV("abcdefghijklmnopqrst"), 10, 5, -8);
     test(S("abcde"), 2, 3, SV("abcdefghijklmnopqrst"), 10, 9, -8);
     test(S("abcde"), 2, 3, SV("abcdefghijklmnopqrst"), 10, 10, -8);
     test(S("abcde"), 2, 3, SV("abcdefghijklmnopqrst"), 10, 11, -8);
 }
 
 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);
     test(S("abcde"), 2, 3, SV("abcdefghijklmnopqrst"), 19, 2, -17);
     test(S("abcde"), 2, 3, SV("abcdefghijklmnopqrst"), 20, 0, 3);
     test(S("abcde"), 2, 3, SV("abcdefghijklmnopqrst"), 20, 1, 3);
     test(S("abcde"), 2, 3, SV("abcdefghijklmnopqrst"), 21, 0, 0);
     test(S("abcde"), 2, 4, SV(""), 0, 0, 3);
TEST_CONSTEXPR_CXX20 void test14()
     test(S("abcde"), 4, 0, SV("abcde"), 2, 0, 0);
     test(S("abcde"), 4, 0, SV("abcde"), 2, 1, -1);
     test(S("abcde"), 4, 0, SV("abcde"), 2, 2, -2);
     test(S("abcde"), 4, 0, SV("abcde"), 2, 3, -3);
     test(S("abcde"), 4, 0, SV("abcde"), 2, 4, -3);
 }
 
 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);
     test(S("abcde"), 4, 0, SV("abcde"), 4, 2, -1);
     test(S("abcde"), 4, 0, SV("abcde"), 5, 0, 0);
     test(S("abcde"), 4, 0, SV("abcde"), 5, 1, 0);
     test(S("abcde"), 4, 0, SV("abcde"), 6, 0, 0);
     test(S("abcde"), 4, 0, SV("abcdefghij"), 0, 0, 0);
TEST_CONSTEXPR_CXX20 void test15()
     test(S("abcde"), 4, 1, SV("abcdefghij"), 5, 4, -1);
     test(S("abcde"), 4, 1, SV("abcdefghij"), 5, 5, -1);
     test(S("abcde"), 4, 1, SV("abcdefghij"), 5, 6, -1);
     test(S("abcde"), 4, 1, SV("abcdefghij"), 9, 0, 1);
     test(S("abcde"), 4, 1, SV("abcdefghij"), 9, 1, -5);
 }
 
 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);
     test(S("abcde"), 4, 1, SV("abcdefghij"), 10, 1, 1);
     test(S("abcde"), 4, 1, SV("abcdefghij"), 11, 0, 0);
     test(S("abcde"), 4, 1, SV("abcdefghijklmnopqrst"), 0, 0, 1);
     test(S("abcde"), 4, 1, SV("abcdefghijklmnopqrst"), 0, 1, 4);
     test(S("abcde"), 4, 1, SV("abcdefghijklmnopqrst"), 0, 10, 4);
TEST_CONSTEXPR_CXX20 void test16()
     test(S("abcde"), 4, 2, SV("abcdefghijklmnopqrst"), 10, 11, -6);
     test(S("abcde"), 4, 2, SV("abcdefghijklmnopqrst"), 19, 0, 1);
     test(S("abcde"), 4, 2, SV("abcdefghijklmnopqrst"), 19, 1, -15);
     test(S("abcde"), 4, 2, SV("abcdefghijklmnopqrst"), 19, 2, -15);
     test(S("abcde"), 4, 2, SV("abcdefghijklmnopqrst"), 20, 0, 1);
 }
 
 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);
     test(S("abcde"), 5, 0, SV(""), 0, 0, 0);
     test(S("abcde"), 5, 0, SV(""), 0, 1, 0);
     test(S("abcde"), 5, 0, SV(""), 1, 0, 0);
     test(S("abcde"), 5, 0, SV("abcde"), 0, 0, 0);
     test(S("abcde"), 5, 0, SV("abcde"), 0, 1, -1);
TEST_CONSTEXPR_CXX20 void test17()
     test(S("abcde"), 5, 1, SV("abcde"), 2, 4, -3);
     test(S("abcde"), 5, 1, SV("abcde"), 4, 0, 0);
     test(S("abcde"), 5, 1, SV("abcde"), 4, 1, -1);
     test(S("abcde"), 5, 1, SV("abcde"), 4, 2, -1);
     test(S("abcde"), 5, 1, SV("abcde"), 5, 0, 0);
 }
 
 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);
     test(S("abcde"), 5, 1, SV("abcdefghij"), 0, 0, 0);
     test(S("abcde"), 5, 1, SV("abcdefghij"), 0, 1, -1);
     test(S("abcde"), 5, 1, SV("abcdefghij"), 0, 5, -5);
     test(S("abcde"), 5, 1, SV("abcdefghij"), 0, 9, -9);
     test(S("abcde"), 5, 1, SV("abcdefghij"), 0, 10, -10);
TEST_CONSTEXPR_CXX20 void test18()
     test(S("abcde"), 6, 0, SV("abcdefghij"), 9, 1, 0);
     test(S("abcde"), 6, 0, SV("abcdefghij"), 9, 2, 0);
     test(S("abcde"), 6, 0, SV("abcdefghij"), 10, 0, 0);
     test(S("abcde"), 6, 0, SV("abcdefghij"), 10, 1, 0);
     test(S("abcde"), 6, 0, SV("abcdefghij"), 11, 0, 0);
 }
 
 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);
     test(S("abcde"), 6, 0, SV("abcdefghijklmnopqrst"), 0, 10, 0);
     test(S("abcde"), 6, 0, SV("abcdefghijklmnopqrst"), 0, 19, 0);
     test(S("abcde"), 6, 0, SV("abcdefghijklmnopqrst"), 0, 20, 0);
     test(S("abcde"), 6, 0, SV("abcdefghijklmnopqrst"), 0, 21, 0);
     test(S("abcde"), 6, 0, SV("abcdefghijklmnopqrst"), 1, 0, 0);
TEST_CONSTEXPR_CXX20 void test19()
     test(S("abcdefghij"), 0, 0, SV("abcdefghijklmnopqrst"), 20, 0, 0);
     test(S("abcdefghij"), 0, 0, SV("abcdefghijklmnopqrst"), 20, 1, 0);
     test(S("abcdefghij"), 0, 0, SV("abcdefghijklmnopqrst"), 21, 0, 0);
     test(S("abcdefghij"), 0, 1, SV(""), 0, 0, 1);
     test(S("abcdefghij"), 0, 1, SV(""), 0, 1, 1);
 }
 
 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);
     test(S("abcdefghij"), 0, 1, SV("abcde"), 0, 1, 0);
     test(S("abcdefghij"), 0, 1, SV("abcde"), 0, 2, -1);
     test(S("abcdefghij"), 0, 1, SV("abcde"), 0, 4, -3);
     test(S("abcdefghij"), 0, 1, SV("abcde"), 0, 5, -4);
     test(S("abcdefghij"), 0, 1, SV("abcde"), 0, 6, -4);
TEST_CONSTEXPR_CXX20 void test20()
     test(S("abcdefghij"), 0, 5, SV("abcde"), 5, 0, 5);
     test(S("abcdefghij"), 0, 5, SV("abcde"), 5, 1, 5);
     test(S("abcdefghij"), 0, 5, SV("abcde"), 6, 0, 0);
     test(S("abcdefghij"), 0, 5, SV("abcdefghij"), 0, 0, 5);
     test(S("abcdefghij"), 0, 5, SV("abcdefghij"), 0, 1, 4);
 }
 
 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);
     test(S("abcdefghij"), 0, 5, SV("abcdefghij"), 0, 10, -5);
     test(S("abcdefghij"), 0, 5, SV("abcdefghij"), 0, 11, -5);
     test(S("abcdefghij"), 0, 5, SV("abcdefghij"), 1, 0, 5);
     test(S("abcdefghij"), 0, 5, SV("abcdefghij"), 1, 1, -1);
     test(S("abcdefghij"), 0, 5, SV("abcdefghij"), 1, 4, -1);
TEST_CONSTEXPR_CXX20 void test21()
     test(S("abcdefghij"), 0, 9, SV("abcdefghij"), 11, 0, 0);
     test(S("abcdefghij"), 0, 9, SV("abcdefghijklmnopqrst"), 0, 0, 9);
     test(S("abcdefghij"), 0, 9, SV("abcdefghijklmnopqrst"), 0, 1, 8);
     test(S("abcdefghij"), 0, 9, SV("abcdefghijklmnopqrst"), 0, 10, -1);
     test(S("abcdefghij"), 0, 9, SV("abcdefghijklmnopqrst"), 0, 19, -10);
 }
 
 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);
     test(S("abcdefghij"), 0, 9, SV("abcdefghijklmnopqrst"), 1, 0, 9);
     test(S("abcdefghij"), 0, 9, SV("abcdefghijklmnopqrst"), 1, 1, -1);
     test(S("abcdefghij"), 0, 9, SV("abcdefghijklmnopqrst"), 1, 9, -1);
     test(S("abcdefghij"), 0, 9, SV("abcdefghijklmnopqrst"), 1, 18, -1);
     test(S("abcdefghij"), 0, 9, SV("abcdefghijklmnopqrst"), 1, 19, -1);
TEST_CONSTEXPR_CXX20 void test22()
     test(S("abcdefghij"), 0, 11, SV(""), 0, 1, 10);
     test(S("abcdefghij"), 0, 11, SV(""), 1, 0, 0);
     test(S("abcdefghij"), 0, 11, SV("abcde"), 0, 0, 10);
     test(S("abcdefghij"), 0, 11, SV("abcde"), 0, 1, 9);
     test(S("abcdefghij"), 0, 11, SV("abcde"), 0, 2, 8);
 }
 
 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);
     test(S("abcdefghij"), 0, 11, SV("abcde"), 0, 6, 5);
     test(S("abcdefghij"), 0, 11, SV("abcde"), 1, 0, 10);
     test(S("abcdefghij"), 0, 11, SV("abcde"), 1, 1, -1);
     test(S("abcdefghij"), 0, 11, SV("abcde"), 1, 2, -1);
     test(S("abcdefghij"), 0, 11, SV("abcde"), 1, 3, -1);
TEST_CONSTEXPR_CXX20 void test23()
     test(S("abcdefghij"), 1, 0, SV("abcdefghij"), 0, 1, -1);
     test(S("abcdefghij"), 1, 0, SV("abcdefghij"), 0, 5, -5);
     test(S("abcdefghij"), 1, 0, SV("abcdefghij"), 0, 9, -9);
     test(S("abcdefghij"), 1, 0, SV("abcdefghij"), 0, 10, -10);
     test(S("abcdefghij"), 1, 0, SV("abcdefghij"), 0, 11, -10);
 }
 
 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);
     test(S("abcdefghij"), 1, 0, SV("abcdefghij"), 1, 4, -4);
     test(S("abcdefghij"), 1, 0, SV("abcdefghij"), 1, 8, -8);
     test(S("abcdefghij"), 1, 0, SV("abcdefghij"), 1, 9, -9);
     test(S("abcdefghij"), 1, 0, SV("abcdefghij"), 1, 10, -9);
     test(S("abcdefghij"), 1, 0, SV("abcdefghij"), 5, 0, 0);
TEST_CONSTEXPR_CXX20 void test24()
     test(S("abcdefghij"), 1, 1, SV("abcdefghijklmnopqrst"), 0, 19, 1);
     test(S("abcdefghij"), 1, 1, SV("abcdefghijklmnopqrst"), 0, 20, 1);
     test(S("abcdefghij"), 1, 1, SV("abcdefghijklmnopqrst"), 0, 21, 1);
     test(S("abcdefghij"), 1, 1, SV("abcdefghijklmnopqrst"), 1, 0, 1);
     test(S("abcdefghij"), 1, 1, SV("abcdefghijklmnopqrst"), 1, 1, 0);
 }
 
 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);
     test(S("abcdefghij"), 1, 1, SV("abcdefghijklmnopqrst"), 1, 19, -18);
     test(S("abcdefghij"), 1, 1, SV("abcdefghijklmnopqrst"), 1, 20, -18);
     test(S("abcdefghij"), 1, 1, SV("abcdefghijklmnopqrst"), 10, 0, 1);
     test(S("abcdefghij"), 1, 1, SV("abcdefghijklmnopqrst"), 10, 1, -9);
     test(S("abcdefghij"), 1, 1, SV("abcdefghijklmnopqrst"), 10, 5, -9);
TEST_CONSTEXPR_CXX20 void test25()
     test(S("abcdefghij"), 1, 8, SV("abcde"), 0, 2, 1);
     test(S("abcdefghij"), 1, 8, SV("abcde"), 0, 4, 1);
     test(S("abcdefghij"), 1, 8, SV("abcde"), 0, 5, 1);
     test(S("abcdefghij"), 1, 8, SV("abcde"), 0, 6, 1);
     test(S("abcdefghij"), 1, 8, SV("abcde"), 1, 0, 8);
 }
 
 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);
     test(S("abcdefghij"), 1, 8, SV("abcde"), 1, 3, 5);
     test(S("abcdefghij"), 1, 8, SV("abcde"), 1, 4, 4);
     test(S("abcdefghij"), 1, 8, SV("abcde"), 1, 5, 4);
     test(S("abcdefghij"), 1, 8, SV("abcde"), 2, 0, 8);
     test(S("abcdefghij"), 1, 8, SV("abcde"), 2, 1, -1);
TEST_CONSTEXPR_CXX20 void test26()
     test(S("abcdefghij"), 1, 9, SV("abcdefghij"), 0, 11, 1);
     test(S("abcdefghij"), 1, 9, SV("abcdefghij"), 1, 0, 9);
     test(S("abcdefghij"), 1, 9, SV("abcdefghij"), 1, 1, 8);
     test(S("abcdefghij"), 1, 9, SV("abcdefghij"), 1, 4, 5);
     test(S("abcdefghij"), 1, 9, SV("abcdefghij"), 1, 8, 1);
 }
 
 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);
     test(S("abcdefghij"), 1, 9, SV("abcdefghij"), 5, 0, 9);
     test(S("abcdefghij"), 1, 9, SV("abcdefghij"), 5, 1, -4);
     test(S("abcdefghij"), 1, 9, SV("abcdefghij"), 5, 2, -4);
     test(S("abcdefghij"), 1, 9, SV("abcdefghij"), 5, 4, -4);
     test(S("abcdefghij"), 1, 9, SV("abcdefghij"), 5, 5, -4);
TEST_CONSTEXPR_CXX20 void test27()
     test(S("abcdefghij"), 1, 10, SV("abcdefghijklmnopqrst"), 1, 1, 8);
     test(S("abcdefghij"), 1, 10, SV("abcdefghijklmnopqrst"), 1, 9, 0);
     test(S("abcdefghij"), 1, 10, SV("abcdefghijklmnopqrst"), 1, 18, -9);
     test(S("abcdefghij"), 1, 10, SV("abcdefghijklmnopqrst"), 1, 19, -10);
     test(S("abcdefghij"), 1, 10, SV("abcdefghijklmnopqrst"), 1, 20, -10);
 }
 
 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);
     test(S("abcdefghij"), 1, 10, SV("abcdefghijklmnopqrst"), 10, 5, -9);
     test(S("abcdefghij"), 1, 10, SV("abcdefghijklmnopqrst"), 10, 9, -9);
     test(S("abcdefghij"), 1, 10, SV("abcdefghijklmnopqrst"), 10, 10, -9);
     test(S("abcdefghij"), 1, 10, SV("abcdefghijklmnopqrst"), 10, 11, -9);
     test(S("abcdefghij"), 1, 10, SV("abcdefghijklmnopqrst"), 19, 0, 9);
TEST_CONSTEXPR_CXX20 void test28()
     test(S("abcdefghij"), 5, 1, SV("abcde"), 1, 0, 1);
     test(S("abcdefghij"), 5, 1, SV("abcde"), 1, 1, 4);
     test(S("abcdefghij"), 5, 1, SV("abcde"), 1, 2, 4);
     test(S("abcdefghij"), 5, 1, SV("abcde"), 1, 3, 4);
     test(S("abcdefghij"), 5, 1, SV("abcde"), 1, 4, 4);
 }
 
 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);
     test(S("abcdefghij"), 5, 1, SV("abcde"), 2, 1, 3);
     test(S("abcdefghij"), 5, 1, SV("abcde"), 2, 2, 3);
     test(S("abcdefghij"), 5, 1, SV("abcde"), 2, 3, 3);
     test(S("abcdefghij"), 5, 1, SV("abcde"), 2, 4, 3);
     test(S("abcdefghij"), 5, 1, SV("abcde"), 4, 0, 1);
TEST_CONSTEXPR_CXX20 void test29()
     test(S("abcdefghij"), 5, 2, SV("abcdefghij"), 1, 8, 4);
     test(S("abcdefghij"), 5, 2, SV("abcdefghij"), 1, 9, 4);
     test(S("abcdefghij"), 5, 2, SV("abcdefghij"), 1, 10, 4);
     test(S("abcdefghij"), 5, 2, SV("abcdefghij"), 5, 0, 2);
     test(S("abcdefghij"), 5, 2, SV("abcdefghij"), 5, 1, 1);
 }
 
 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);
     test(S("abcdefghij"), 5, 2, SV("abcdefghij"), 5, 5, -3);
     test(S("abcdefghij"), 5, 2, SV("abcdefghij"), 5, 6, -3);
     test(S("abcdefghij"), 5, 2, SV("abcdefghij"), 9, 0, 2);
     test(S("abcdefghij"), 5, 2, SV("abcdefghij"), 9, 1, -4);
     test(S("abcdefghij"), 5, 2, SV("abcdefghij"), 9, 2, -4);
TEST_CONSTEXPR_CXX20 void test30()
     test(S("abcdefghij"), 5, 4, SV("abcdefghijklmnopqrst"), 1, 20, 4);
     test(S("abcdefghij"), 5, 4, SV("abcdefghijklmnopqrst"), 10, 0, 4);
     test(S("abcdefghij"), 5, 4, SV("abcdefghijklmnopqrst"), 10, 1, -5);
     test(S("abcdefghij"), 5, 4, SV("abcdefghijklmnopqrst"), 10, 5, -5);
     test(S("abcdefghij"), 5, 4, SV("abcdefghijklmnopqrst"), 10, 9, -5);
 }
 
 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);
     test(S("abcdefghij"), 5, 4, SV("abcdefghijklmnopqrst"), 19, 0, 4);
     test(S("abcdefghij"), 5, 4, SV("abcdefghijklmnopqrst"), 19, 1, -14);
     test(S("abcdefghij"), 5, 4, SV("abcdefghijklmnopqrst"), 19, 2, -14);
     test(S("abcdefghij"), 5, 4, SV("abcdefghijklmnopqrst"), 20, 0, 4);
     test(S("abcdefghij"), 5, 4, SV("abcdefghijklmnopqrst"), 20, 1, 4);
TEST_CONSTEXPR_CXX20 void test31()
     test(S("abcdefghij"), 5, 6, SV("abcde"), 1, 4, 4);
     test(S("abcdefghij"), 5, 6, SV("abcde"), 1, 5, 4);
     test(S("abcdefghij"), 5, 6, SV("abcde"), 2, 0, 5);
     test(S("abcdefghij"), 5, 6, SV("abcde"), 2, 1, 3);
     test(S("abcdefghij"), 5, 6, SV("abcde"), 2, 2, 3);
 }
 
 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);
     test(S("abcdefghij"), 5, 6, SV("abcde"), 4, 0, 5);
     test(S("abcdefghij"), 5, 6, SV("abcde"), 4, 1, 1);
     test(S("abcdefghij"), 5, 6, SV("abcde"), 4, 2, 1);
     test(S("abcdefghij"), 5, 6, SV("abcde"), 5, 0, 5);
     test(S("abcdefghij"), 5, 6, SV("abcde"), 5, 1, 5);
TEST_CONSTEXPR_CXX20 void test32()
     test(S("abcdefghij"), 9, 0, SV("abcdefghij"), 5, 1, -1);
     test(S("abcdefghij"), 9, 0, SV("abcdefghij"), 5, 2, -2);
     test(S("abcdefghij"), 9, 0, SV("abcdefghij"), 5, 4, -4);
     test(S("abcdefghij"), 9, 0, SV("abcdefghij"), 5, 5, -5);
     test(S("abcdefghij"), 9, 0, SV("abcdefghij"), 5, 6, -5);
 }
 
 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);
     test(S("abcdefghij"), 9, 0, SV("abcdefghij"), 9, 2, -1);
     test(S("abcdefghij"), 9, 0, SV("abcdefghij"), 10, 0, 0);
     test(S("abcdefghij"), 9, 0, SV("abcdefghij"), 10, 1, 0);
     test(S("abcdefghij"), 9, 0, SV("abcdefghij"), 11, 0, 0);
     test(S("abcdefghij"), 9, 0, SV("abcdefghijklmnopqrst"), 0, 0, 0);
TEST_CONSTEXPR_CXX20 void test33()
     test(S("abcdefghij"), 9, 1, SV("abcdefghijklmnopqrst"), 10, 9, -1);
     test(S("abcdefghij"), 9, 1, SV("abcdefghijklmnopqrst"), 10, 10, -1);
     test(S("abcdefghij"), 9, 1, SV("abcdefghijklmnopqrst"), 10, 11, -1);
     test(S("abcdefghij"), 9, 1, SV("abcdefghijklmnopqrst"), 19, 0, 1);
     test(S("abcdefghij"), 9, 1, SV("abcdefghijklmnopqrst"), 19, 1, -10);
 }
 
 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);
     test(S("abcdefghij"), 9, 1, SV("abcdefghijklmnopqrst"), 20, 1, 1);
     test(S("abcdefghij"), 9, 1, SV("abcdefghijklmnopqrst"), 21, 0, 0);
     test(S("abcdefghij"), 9, 2, SV(""), 0, 0, 1);
     test(S("abcdefghij"), 9, 2, SV(""), 0, 1, 1);
     test(S("abcdefghij"), 9, 2, SV(""), 1, 0, 0);
TEST_CONSTEXPR_CXX20 void test34()
     test(S("abcdefghij"), 10, 0, SV("abcde"), 2, 2, -2);
     test(S("abcdefghij"), 10, 0, SV("abcde"), 2, 3, -3);
     test(S("abcdefghij"), 10, 0, SV("abcde"), 2, 4, -3);
     test(S("abcdefghij"), 10, 0, SV("abcde"), 4, 0, 0);
     test(S("abcdefghij"), 10, 0, SV("abcde"), 4, 1, -1);
 }
 
 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);
     test(S("abcdefghij"), 10, 0, SV("abcde"), 5, 1, 0);
     test(S("abcdefghij"), 10, 0, SV("abcde"), 6, 0, 0);
     test(S("abcdefghij"), 10, 0, SV("abcdefghij"), 0, 0, 0);
     test(S("abcdefghij"), 10, 0, SV("abcdefghij"), 0, 1, -1);
     test(S("abcdefghij"), 10, 0, SV("abcdefghij"), 0, 5, -5);
TEST_CONSTEXPR_CXX20 void test35()
     test(S("abcdefghij"), 10, 1, SV("abcdefghij"), 5, 6, -5);
     test(S("abcdefghij"), 10, 1, SV("abcdefghij"), 9, 0, 0);
     test(S("abcdefghij"), 10, 1, SV("abcdefghij"), 9, 1, -1);
     test(S("abcdefghij"), 10, 1, SV("abcdefghij"), 9, 2, -1);
     test(S("abcdefghij"), 10, 1, SV("abcdefghij"), 10, 0, 0);
 }
 
 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);
     test(S("abcdefghij"), 10, 1, SV("abcdefghijklmnopqrst"), 0, 0, 0);
     test(S("abcdefghij"), 10, 1, SV("abcdefghijklmnopqrst"), 0, 1, -1);
     test(S("abcdefghij"), 10, 1, SV("abcdefghijklmnopqrst"), 0, 10, -10);
     test(S("abcdefghij"), 10, 1, SV("abcdefghijklmnopqrst"), 0, 19, -19);
     test(S("abcdefghij"), 10, 1, SV("abcdefghijklmnopqrst"), 0, 20, -20);
TEST_CONSTEXPR_CXX20 void test36()
     test(S("abcdefghij"), 11, 0, SV("abcdefghijklmnopqrst"), 19, 1, 0);
     test(S("abcdefghij"), 11, 0, SV("abcdefghijklmnopqrst"), 19, 2, 0);
     test(S("abcdefghij"), 11, 0, SV("abcdefghijklmnopqrst"), 20, 0, 0);
     test(S("abcdefghij"), 11, 0, SV("abcdefghijklmnopqrst"), 20, 1, 0);
     test(S("abcdefghij"), 11, 0, SV("abcdefghijklmnopqrst"), 21, 0, 0);
 }
 
 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);
     test(S("abcdefghijklmnopqrst"), 0, 0, SV(""), 1, 0, 0);
     test(S("abcdefghijklmnopqrst"), 0, 0, SV("abcde"), 0, 0, 0);
     test(S("abcdefghijklmnopqrst"), 0, 0, SV("abcde"), 0, 1, -1);
     test(S("abcdefghijklmnopqrst"), 0, 0, SV("abcde"), 0, 2, -2);
     test(S("abcdefghijklmnopqrst"), 0, 0, SV("abcde"), 0, 4, -4);
TEST_CONSTEXPR_CXX20 void test37()
     test(S("abcdefghijklmnopqrst"), 0, 1, SV("abcde"), 4, 1, -4);
     test(S("abcdefghijklmnopqrst"), 0, 1, SV("abcde"), 4, 2, -4);
     test(S("abcdefghijklmnopqrst"), 0, 1, SV("abcde"), 5, 0, 1);
     test(S("abcdefghijklmnopqrst"), 0, 1, SV("abcde"), 5, 1, 1);
     test(S("abcdefghijklmnopqrst"), 0, 1, SV("abcde"), 6, 0, 0);
 }
 
 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);
     test(S("abcdefghijklmnopqrst"), 0, 1, SV("abcdefghij"), 0, 5, -4);
     test(S("abcdefghijklmnopqrst"), 0, 1, SV("abcdefghij"), 0, 9, -8);
     test(S("abcdefghijklmnopqrst"), 0, 1, SV("abcdefghij"), 0, 10, -9);
     test(S("abcdefghijklmnopqrst"), 0, 1, SV("abcdefghij"), 0, 11, -9);
     test(S("abcdefghijklmnopqrst"), 0, 1, SV("abcdefghij"), 1, 0, 1);
TEST_CONSTEXPR_CXX20 void test38()
     test(S("abcdefghijklmnopqrst"), 0, 10, SV("abcdefghij"), 10, 0, 10);
     test(S("abcdefghijklmnopqrst"), 0, 10, SV("abcdefghij"), 10, 1, 10);
     test(S("abcdefghijklmnopqrst"), 0, 10, SV("abcdefghij"), 11, 0, 0);
     test(S("abcdefghijklmnopqrst"), 0, 10, SV("abcdefghijklmnopqrst"), 0, 0, 10);
     test(S("abcdefghijklmnopqrst"), 0, 10, SV("abcdefghijklmnopqrst"), 0, 1, 9);
 }
 
 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);
     test(S("abcdefghijklmnopqrst"), 0, 10, SV("abcdefghijklmnopqrst"), 0, 20, -10);
     test(S("abcdefghijklmnopqrst"), 0, 10, SV("abcdefghijklmnopqrst"), 0, 21, -10);
     test(S("abcdefghijklmnopqrst"), 0, 10, SV("abcdefghijklmnopqrst"), 1, 0, 10);
     test(S("abcdefghijklmnopqrst"), 0, 10, SV("abcdefghijklmnopqrst"), 1, 1, -1);
     test(S("abcdefghijklmnopqrst"), 0, 10, SV("abcdefghijklmnopqrst"), 1, 9, -1);
TEST_CONSTEXPR_CXX20 void test39()
     test(S("abcdefghijklmnopqrst"), 0, 19, SV("abcdefghijklmnopqrst"), 21, 0, 0);
     test(S("abcdefghijklmnopqrst"), 0, 20, SV(""), 0, 0, 20);
     test(S("abcdefghijklmnopqrst"), 0, 20, SV(""), 0, 1, 20);
     test(S("abcdefghijklmnopqrst"), 0, 20, SV(""), 1, 0, 0);
     test(S("abcdefghijklmnopqrst"), 0, 20, SV("abcde"), 0, 0, 20);
 }
 
 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);
     test(S("abcdefghijklmnopqrst"), 0, 20, SV("abcde"), 0, 4, 16);
     test(S("abcdefghijklmnopqrst"), 0, 20, SV("abcde"), 0, 5, 15);
     test(S("abcdefghijklmnopqrst"), 0, 20, SV("abcde"), 0, 6, 15);
     test(S("abcdefghijklmnopqrst"), 0, 20, SV("abcde"), 1, 0, 20);
     test(S("abcdefghijklmnopqrst"), 0, 20, SV("abcde"), 1, 1, -1);
TEST_CONSTEXPR_CXX20 void test40()
     test(S("abcdefghijklmnopqrst"), 0, 21, SV("abcde"), 6, 0, 0);
     test(S("abcdefghijklmnopqrst"), 0, 21, SV("abcdefghij"), 0, 0, 20);
     test(S("abcdefghijklmnopqrst"), 0, 21, SV("abcdefghij"), 0, 1, 19);
     test(S("abcdefghijklmnopqrst"), 0, 21, SV("abcdefghij"), 0, 5, 15);
     test(S("abcdefghijklmnopqrst"), 0, 21, SV("abcdefghij"), 0, 9, 11);
 }
 
 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);
     test(S("abcdefghijklmnopqrst"), 0, 21, SV("abcdefghij"), 1, 0, 20);
     test(S("abcdefghijklmnopqrst"), 0, 21, SV("abcdefghij"), 1, 1, -1);
     test(S("abcdefghijklmnopqrst"), 0, 21, SV("abcdefghij"), 1, 4, -1);
     test(S("abcdefghijklmnopqrst"), 0, 21, SV("abcdefghij"), 1, 8, -1);
     test(S("abcdefghijklmnopqrst"), 0, 21, SV("abcdefghij"), 1, 9, -1);
TEST_CONSTEXPR_CXX20 void test41()
     test(S("abcdefghijklmnopqrst"), 1, 0, SV("abcdefghijklmnopqrst"), 0, 1, -1);
     test(S("abcdefghijklmnopqrst"), 1, 0, SV("abcdefghijklmnopqrst"), 0, 10, -10);
     test(S("abcdefghijklmnopqrst"), 1, 0, SV("abcdefghijklmnopqrst"), 0, 19, -19);
     test(S("abcdefghijklmnopqrst"), 1, 0, SV("abcdefghijklmnopqrst"), 0, 20, -20);
     test(S("abcdefghijklmnopqrst"), 1, 0, SV("abcdefghijklmnopqrst"), 0, 21, -20);
 }
 
 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);
     test(S("abcdefghijklmnopqrst"), 1, 0, SV("abcdefghijklmnopqrst"), 1, 9, -9);
     test(S("abcdefghijklmnopqrst"), 1, 0, SV("abcdefghijklmnopqrst"), 1, 18, -18);
     test(S("abcdefghijklmnopqrst"), 1, 0, SV("abcdefghijklmnopqrst"), 1, 19, -19);
     test(S("abcdefghijklmnopqrst"), 1, 0, SV("abcdefghijklmnopqrst"), 1, 20, -19);
     test(S("abcdefghijklmnopqrst"), 1, 0, SV("abcdefghijklmnopqrst"), 10, 0, 0);
TEST_CONSTEXPR_CXX20 void test42()
     test(S("abcdefghijklmnopqrst"), 1, 9, SV("abcde"), 0, 0, 9);
     test(S("abcdefghijklmnopqrst"), 1, 9, SV("abcde"), 0, 1, 1);
     test(S("abcdefghijklmnopqrst"), 1, 9, SV("abcde"), 0, 2, 1);
     test(S("abcdefghijklmnopqrst"), 1, 9, SV("abcde"), 0, 4, 1);
     test(S("abcdefghijklmnopqrst"), 1, 9, SV("abcde"), 0, 5, 1);
 }
 
 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);
     test(S("abcdefghijklmnopqrst"), 1, 9, SV("abcde"), 1, 1, 8);
     test(S("abcdefghijklmnopqrst"), 1, 9, SV("abcde"), 1, 2, 7);
     test(S("abcdefghijklmnopqrst"), 1, 9, SV("abcde"), 1, 3, 6);
     test(S("abcdefghijklmnopqrst"), 1, 9, SV("abcde"), 1, 4, 5);
     test(S("abcdefghijklmnopqrst"), 1, 9, SV("abcde"), 1, 5, 5);
TEST_CONSTEXPR_CXX20 void test43()
     test(S("abcdefghijklmnopqrst"), 1, 18, SV("abcdefghij"), 0, 9, 1);
     test(S("abcdefghijklmnopqrst"), 1, 18, SV("abcdefghij"), 0, 10, 1);
     test(S("abcdefghijklmnopqrst"), 1, 18, SV("abcdefghij"), 0, 11, 1);
     test(S("abcdefghijklmnopqrst"), 1, 18, SV("abcdefghij"), 1, 0, 18);
     test(S("abcdefghijklmnopqrst"), 1, 18, SV("abcdefghij"), 1, 1, 17);
 }
 
 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);
     test(S("abcdefghijklmnopqrst"), 1, 18, SV("abcdefghij"), 1, 9, 9);
     test(S("abcdefghijklmnopqrst"), 1, 18, SV("abcdefghij"), 1, 10, 9);
     test(S("abcdefghijklmnopqrst"), 1, 18, SV("abcdefghij"), 5, 0, 18);
     test(S("abcdefghijklmnopqrst"), 1, 18, SV("abcdefghij"), 5, 1, -4);
     test(S("abcdefghijklmnopqrst"), 1, 18, SV("abcdefghij"), 5, 2, -4);
TEST_CONSTEXPR_CXX20 void test44()
     test(S("abcdefghijklmnopqrst"), 1, 19, SV("abcdefghijklmnopqrst"), 0, 21, 1);
     test(S("abcdefghijklmnopqrst"), 1, 19, SV("abcdefghijklmnopqrst"), 1, 0, 19);
     test(S("abcdefghijklmnopqrst"), 1, 19, SV("abcdefghijklmnopqrst"), 1, 1, 18);
     test(S("abcdefghijklmnopqrst"), 1, 19, SV("abcdefghijklmnopqrst"), 1, 9, 10);
     test(S("abcdefghijklmnopqrst"), 1, 19, SV("abcdefghijklmnopqrst"), 1, 18, 1);
 }
 
 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);
     test(S("abcdefghijklmnopqrst"), 1, 19, SV("abcdefghijklmnopqrst"), 10, 0, 19);
     test(S("abcdefghijklmnopqrst"), 1, 19, SV("abcdefghijklmnopqrst"), 10, 1, -9);
     test(S("abcdefghijklmnopqrst"), 1, 19, SV("abcdefghijklmnopqrst"), 10, 5, -9);
     test(S("abcdefghijklmnopqrst"), 1, 19, SV("abcdefghijklmnopqrst"), 10, 9, -9);
     test(S("abcdefghijklmnopqrst"), 1, 19, SV("abcdefghijklmnopqrst"), 10, 10, -9);
TEST_CONSTEXPR_CXX20 void test45()
     test(S("abcdefghijklmnopqrst"), 10, 0, SV("abcde"), 0, 5, -5);
     test(S("abcdefghijklmnopqrst"), 10, 0, SV("abcde"), 0, 6, -5);
     test(S("abcdefghijklmnopqrst"), 10, 0, SV("abcde"), 1, 0, 0);
     test(S("abcdefghijklmnopqrst"), 10, 0, SV("abcde"), 1, 1, -1);
     test(S("abcdefghijklmnopqrst"), 10, 0, SV("abcde"), 1, 2, -2);
 }
 
 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);
     test(S("abcdefghijklmnopqrst"), 10, 0, SV("abcde"), 1, 5, -4);
     test(S("abcdefghijklmnopqrst"), 10, 0, SV("abcde"), 2, 0, 0);
     test(S("abcdefghijklmnopqrst"), 10, 0, SV("abcde"), 2, 1, -1);
     test(S("abcdefghijklmnopqrst"), 10, 0, SV("abcde"), 2, 2, -2);
     test(S("abcdefghijklmnopqrst"), 10, 0, SV("abcde"), 2, 3, -3);
TEST_CONSTEXPR_CXX20 void test46()
     test(S("abcdefghijklmnopqrst"), 10, 1, SV("abcdefghij"), 1, 1, 9);
     test(S("abcdefghijklmnopqrst"), 10, 1, SV("abcdefghij"), 1, 4, 9);
     test(S("abcdefghijklmnopqrst"), 10, 1, SV("abcdefghij"), 1, 8, 9);
     test(S("abcdefghijklmnopqrst"), 10, 1, SV("abcdefghij"), 1, 9, 9);
     test(S("abcdefghijklmnopqrst"), 10, 1, SV("abcdefghij"), 1, 10, 9);
 }
 
 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);
     test(S("abcdefghijklmnopqrst"), 10, 1, SV("abcdefghij"), 5, 2, 5);
     test(S("abcdefghijklmnopqrst"), 10, 1, SV("abcdefghij"), 5, 4, 5);
     test(S("abcdefghijklmnopqrst"), 10, 1, SV("abcdefghij"), 5, 5, 5);
     test(S("abcdefghijklmnopqrst"), 10, 1, SV("abcdefghij"), 5, 6, 5);
     test(S("abcdefghijklmnopqrst"), 10, 1, SV("abcdefghij"), 9, 0, 1);
TEST_CONSTEXPR_CXX20 void test47()
     test(S("abcdefghijklmnopqrst"), 10, 5, SV("abcdefghijklmnopqrst"), 1, 18, 9);
     test(S("abcdefghijklmnopqrst"), 10, 5, SV("abcdefghijklmnopqrst"), 1, 19, 9);
     test(S("abcdefghijklmnopqrst"), 10, 5, SV("abcdefghijklmnopqrst"), 1, 20, 9);
     test(S("abcdefghijklmnopqrst"), 10, 5, SV("abcdefghijklmnopqrst"), 10, 0, 5);
     test(S("abcdefghijklmnopqrst"), 10, 5, SV("abcdefghijklmnopqrst"), 10, 1, 4);
 }
 
 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);
     test(S("abcdefghijklmnopqrst"), 10, 5, SV("abcdefghijklmnopqrst"), 10, 10, -5);
     test(S("abcdefghijklmnopqrst"), 10, 5, SV("abcdefghijklmnopqrst"), 10, 11, -5);
     test(S("abcdefghijklmnopqrst"), 10, 5, SV("abcdefghijklmnopqrst"), 19, 0, 5);
     test(S("abcdefghijklmnopqrst"), 10, 5, SV("abcdefghijklmnopqrst"), 19, 1, -9);
     test(S("abcdefghijklmnopqrst"), 10, 5, SV("abcdefghijklmnopqrst"), 19, 2, -9);
TEST_CONSTEXPR_CXX20 void test48()
     test(S("abcdefghijklmnopqrst"), 10, 10, SV("abcde"), 1, 2, 9);
     test(S("abcdefghijklmnopqrst"), 10, 10, SV("abcde"), 1, 3, 9);
     test(S("abcdefghijklmnopqrst"), 10, 10, SV("abcde"), 1, 4, 9);
     test(S("abcdefghijklmnopqrst"), 10, 10, SV("abcde"), 1, 5, 9);
     test(S("abcdefghijklmnopqrst"), 10, 10, SV("abcde"), 2, 0, 10);
 }
 
 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);
     test(S("abcdefghijklmnopqrst"), 10, 10, SV("abcde"), 2, 3, 8);
     test(S("abcdefghijklmnopqrst"), 10, 10, SV("abcde"), 2, 4, 8);
     test(S("abcdefghijklmnopqrst"), 10, 10, SV("abcde"), 4, 0, 10);
     test(S("abcdefghijklmnopqrst"), 10, 10, SV("abcde"), 4, 1, 6);
     test(S("abcdefghijklmnopqrst"), 10, 10, SV("abcde"), 4, 2, 6);
TEST_CONSTEXPR_CXX20 void test49()
     test(S("abcdefghijklmnopqrst"), 10, 11, SV("abcdefghij"), 1, 10, 9);
     test(S("abcdefghijklmnopqrst"), 10, 11, SV("abcdefghij"), 5, 0, 10);
     test(S("abcdefghijklmnopqrst"), 10, 11, SV("abcdefghij"), 5, 1, 5);
     test(S("abcdefghijklmnopqrst"), 10, 11, SV("abcdefghij"), 5, 2, 5);
     test(S("abcdefghijklmnopqrst"), 10, 11, SV("abcdefghij"), 5, 4, 5);
 }
 
 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);
     test(S("abcdefghijklmnopqrst"), 10, 11, SV("abcdefghij"), 9, 0, 10);
     test(S("abcdefghijklmnopqrst"), 10, 11, SV("abcdefghij"), 9, 1, 1);
     test(S("abcdefghijklmnopqrst"), 10, 11, SV("abcdefghij"), 9, 2, 1);
     test(S("abcdefghijklmnopqrst"), 10, 11, SV("abcdefghij"), 10, 0, 10);
     test(S("abcdefghijklmnopqrst"), 10, 11, SV("abcdefghij"), 10, 1, 10);
TEST_CONSTEXPR_CXX20 void test50()
     test(S("abcdefghijklmnopqrst"), 19, 0, SV("abcdefghijklmnopqrst"), 10, 1, -1);
     test(S("abcdefghijklmnopqrst"), 19, 0, SV("abcdefghijklmnopqrst"), 10, 5, -5);
     test(S("abcdefghijklmnopqrst"), 19, 0, SV("abcdefghijklmnopqrst"), 10, 9, -9);
     test(S("abcdefghijklmnopqrst"), 19, 0, SV("abcdefghijklmnopqrst"), 10, 10, -10);
     test(S("abcdefghijklmnopqrst"), 19, 0, SV("abcdefghijklmnopqrst"), 10, 11, -10);
 }
 
 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);
     test(S("abcdefghijklmnopqrst"), 19, 0, SV("abcdefghijklmnopqrst"), 19, 2, -1);
     test(S("abcdefghijklmnopqrst"), 19, 0, SV("abcdefghijklmnopqrst"), 20, 0, 0);
     test(S("abcdefghijklmnopqrst"), 19, 0, SV("abcdefghijklmnopqrst"), 20, 1, 0);
     test(S("abcdefghijklmnopqrst"), 19, 0, SV("abcdefghijklmnopqrst"), 21, 0, 0);
     test(S("abcdefghijklmnopqrst"), 19, 1, SV(""), 0, 0, 1);
TEST_CONSTEXPR_CXX20 void test51()
     test(S("abcdefghijklmnopqrst"), 19, 2, SV("abcde"), 2, 0, 1);
     test(S("abcdefghijklmnopqrst"), 19, 2, SV("abcde"), 2, 1, 17);
     test(S("abcdefghijklmnopqrst"), 19, 2, SV("abcde"), 2, 2, 17);
     test(S("abcdefghijklmnopqrst"), 19, 2, SV("abcde"), 2, 3, 17);
     test(S("abcdefghijklmnopqrst"), 19, 2, SV("abcde"), 2, 4, 17);
 }
 
 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);
     test(S("abcdefghijklmnopqrst"), 19, 2, SV("abcde"), 4, 2, 15);
     test(S("abcdefghijklmnopqrst"), 19, 2, SV("abcde"), 5, 0, 1);
     test(S("abcdefghijklmnopqrst"), 19, 2, SV("abcde"), 5, 1, 1);
     test(S("abcdefghijklmnopqrst"), 19, 2, SV("abcde"), 6, 0, 0);
     test(S("abcdefghijklmnopqrst"), 19, 2, SV("abcdefghij"), 0, 0, 1);
TEST_CONSTEXPR_CXX20 void test52()
     test(S("abcdefghijklmnopqrst"), 20, 0, SV("abcdefghij"), 5, 4, -4);
     test(S("abcdefghijklmnopqrst"), 20, 0, SV("abcdefghij"), 5, 5, -5);
     test(S("abcdefghijklmnopqrst"), 20, 0, SV("abcdefghij"), 5, 6, -5);
     test(S("abcdefghijklmnopqrst"), 20, 0, SV("abcdefghij"), 9, 0, 0);
     test(S("abcdefghijklmnopqrst"), 20, 0, SV("abcdefghij"), 9, 1, -1);
 }
 
 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);
     test(S("abcdefghijklmnopqrst"), 20, 0, SV("abcdefghij"), 10, 1, 0);
     test(S("abcdefghijklmnopqrst"), 20, 0, SV("abcdefghij"), 11, 0, 0);
     test(S("abcdefghijklmnopqrst"), 20, 0, SV("abcdefghijklmnopqrst"), 0, 0, 0);
     test(S("abcdefghijklmnopqrst"), 20, 0, SV("abcdefghijklmnopqrst"), 0, 1, -1);
     test(S("abcdefghijklmnopqrst"), 20, 0, SV("abcdefghijklmnopqrst"), 0, 10, -10);
TEST_CONSTEXPR_CXX20 void test53()
     test(S("abcdefghijklmnopqrst"), 20, 1, SV("abcdefghijklmnopqrst"), 10, 11, -10);
     test(S("abcdefghijklmnopqrst"), 20, 1, SV("abcdefghijklmnopqrst"), 19, 0, 0);
     test(S("abcdefghijklmnopqrst"), 20, 1, SV("abcdefghijklmnopqrst"), 19, 1, -1);
     test(S("abcdefghijklmnopqrst"), 20, 1, SV("abcdefghijklmnopqrst"), 19, 2, -1);
     test(S("abcdefghijklmnopqrst"), 20, 1, SV("abcdefghijklmnopqrst"), 20, 0, 0);
 }
 
 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);
     test(S("abcdefghijklmnopqrst"), 21, 0, SV(""), 0, 0, 0);
     test(S("abcdefghijklmnopqrst"), 21, 0, SV(""), 0, 1, 0);
     test(S("abcdefghijklmnopqrst"), 21, 0, SV(""), 1, 0, 0);
     test(S("abcdefghijklmnopqrst"), 21, 0, SV("abcde"), 0, 0, 0);
     test(S("abcdefghijklmnopqrst"), 21, 0, SV("abcde"), 0, 1, 0);
TEST_CONSTEXPR_CXX20 void test54()
     test(S("abcdefghijklmnopqrst"), 21, 0, SV("abcdefghijklmnopqrst"), 19, 1, 0);
     test(S("abcdefghijklmnopqrst"), 21, 0, SV("abcdefghijklmnopqrst"), 19, 2, 0);
     test(S("abcdefghijklmnopqrst"), 21, 0, SV("abcdefghijklmnopqrst"), 20, 0, 0);
     test(S("abcdefghijklmnopqrst"), 21, 0, SV("abcdefghijklmnopqrst"), 20, 1, 0);
     test(S("abcdefghijklmnopqrst"), 21, 0, SV("abcdefghijklmnopqrst"), 21, 0, 0);
 }
 
 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);
     test_npos(S("abcde"), 0, 0, SV("abcdefghij"), 0, -10);
     test_npos(S("abcde"), 0, 0, SV("abcdefghij"), 1, -9);
     test_npos(S("abcde"), 0, 0, SV("abcdefghij"), 5, -5);
 }
 
-int main(int, char**)
-{
-    {
-    typedef std::string S;
-    typedef std::string_view SV;
+template<class S, class SV>
+TEST_CONSTEXPR_CXX20 bool test_0() {
     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;
-    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>();
+
+    return true;
+
+template<class S, class SV>
+TEST_CONSTEXPR_CXX20 bool test_1() {
     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>();
+
+    return true;
+}
+
+template<class S, class SV>
+TEST_CONSTEXPR_CXX20 bool test_2() {
     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>();
+
+    return true;
+}
+
+template<class S, class SV>
+TEST_CONSTEXPR_CXX20 bool test_3() {
     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>();
-    }
-#endif
+
+    return true;
+
+TEST_CONSTEXPR_CXX20 bool test_4() {
     {
     typedef std::string S;
     typedef std::string_view SV;
     S s = "MNOP";
     SV sv = "CDEF";
     char arr[] = "MNOP";
 
 //  calls compare(pos, n1, const char *, 0)
//  calls compare(pos, n1, T, 0, npos)
     assert(s.compare(0, 4, sv, 0, std::string::npos) > 0);
 
 // calls compare(pos, n1, const char *, 0)
     assert(s.compare(0, 4, arr, 0) > 0);
 
 //  calls compare(size, size, string(arr), 0, npos)
     assert(s.compare(0, 4, arr, 0, std::string::npos) == 0);
     }
     
-  return 0;
+  return true;
+}
+
+int main(int, char**) {
+  {
+    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

libcxx/test/std/strings/basic.string/string.ops/string_compare/size_size_pointer_size.pass.cpp

 #include <string>
 #include <stdexcept>
 #include <cassert>
 
 #include "min_allocator.h"
 
 #include "test_macros.h"
 
-int sign(int x)
+TEST_CONSTEXPR_CXX20 int sign(int x)
 {
     if (x == 0)
         return 0;
     if (x < 0)
         return -1;
     return 1;
 }
 
 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
         {
             TEST_IGNORE_NODISCARD s.compare(pos, n1, str, n2);
             assert(false);
         }
         catch (std::out_of_range&)
         {
             assert(pos > s.size());
         }
     }
 #endif
 }
 
 template <class S>
-void test0()
+TEST_CONSTEXPR_CXX20 void test0()
 {
     test(S(""), 0, 0, "", 0, 0);
     test(S(""), 0, 0, "abcde", 0, 0);
     test(S(""), 0, 0, "abcde", 1, -1);
     test(S(""), 0, 0, "abcde", 2, -2);
     test(S(""), 0, 0, "abcde", 4, -4);
     test(S(""), 0, 0, "abcde", 5, -5);
     test(S(""), 0, 0, "abcdefghij", 0, 0);
TEST_CONSTEXPR_CXX20 void test0()
     test(S("abcde"), 0, 2, "abcdefghijklmnopqrst", 20, -18);
     test(S("abcde"), 0, 4, "", 0, 4);
     test(S("abcde"), 0, 4, "abcde", 0, 4);
     test(S("abcde"), 0, 4, "abcde", 1, 3);
     test(S("abcde"), 0, 4, "abcde", 2, 2);
 }
 
 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);
     test(S("abcde"), 0, 4, "abcdefghij", 0, 4);
     test(S("abcde"), 0, 4, "abcdefghij", 1, 3);
     test(S("abcde"), 0, 4, "abcdefghij", 5, -1);
     test(S("abcde"), 0, 4, "abcdefghij", 9, -5);
     test(S("abcde"), 0, 4, "abcdefghij", 10, -6);
TEST_CONSTEXPR_CXX20 void test1()
     test(S("abcde"), 1, 3, "abcde", 2, 1);
     test(S("abcde"), 1, 3, "abcde", 4, 1);
     test(S("abcde"), 1, 3, "abcde", 5, 1);
     test(S("abcde"), 1, 3, "abcdefghij", 0, 3);
     test(S("abcde"), 1, 3, "abcdefghij", 1, 1);
 }
 
 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);
     test(S("abcde"), 1, 3, "abcdefghij", 10, 1);
     test(S("abcde"), 1, 3, "abcdefghijklmnopqrst", 0, 3);
     test(S("abcde"), 1, 3, "abcdefghijklmnopqrst", 1, 1);
     test(S("abcde"), 1, 3, "abcdefghijklmnopqrst", 10, 1);
     test(S("abcde"), 1, 3, "abcdefghijklmnopqrst", 19, 1);
TEST_CONSTEXPR_CXX20 void test2()
     test(S("abcde"), 2, 3, "abcdefghij", 1, 2);
     test(S("abcde"), 2, 3, "abcdefghij", 5, 2);
     test(S("abcde"), 2, 3, "abcdefghij", 9, 2);
     test(S("abcde"), 2, 3, "abcdefghij", 10, 2);
     test(S("abcde"), 2, 3, "abcdefghijklmnopqrst", 0, 3);
 }
 
 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);
     test(S("abcde"), 2, 3, "abcdefghijklmnopqrst", 19, 2);
     test(S("abcde"), 2, 3, "abcdefghijklmnopqrst", 20, 2);
     test(S("abcde"), 2, 4, "", 0, 3);
     test(S("abcde"), 2, 4, "abcde", 0, 3);
     test(S("abcde"), 2, 4, "abcde", 1, 2);
TEST_CONSTEXPR_CXX20 void test3()
     test(S("abcde"), 5, 1, "abcdefghijklmnopqrst", 0, 0);
     test(S("abcde"), 5, 1, "abcdefghijklmnopqrst", 1, -1);
     test(S("abcde"), 5, 1, "abcdefghijklmnopqrst", 10, -10);
     test(S("abcde"), 5, 1, "abcdefghijklmnopqrst", 19, -19);
     test(S("abcde"), 5, 1, "abcdefghijklmnopqrst", 20, -20);
 }
 
 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);
     test(S("abcde"), 6, 0, "abcde", 1, 0);
     test(S("abcde"), 6, 0, "abcde", 2, 0);
     test(S("abcde"), 6, 0, "abcde", 4, 0);
     test(S("abcde"), 6, 0, "abcde", 5, 0);
     test(S("abcde"), 6, 0, "abcdefghij", 0, 0);
TEST_CONSTEXPR_CXX20 void test4()
     test(S("abcdefghij"), 0, 10, "abcdefghijklmnopqrst", 20, -10);
     test(S("abcdefghij"), 0, 11, "", 0, 10);
     test(S("abcdefghij"), 0, 11, "abcde", 0, 10);
     test(S("abcdefghij"), 0, 11, "abcde", 1, 9);
     test(S("abcdefghij"), 0, 11, "abcde", 2, 8);
 }
 
 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);
     test(S("abcdefghij"), 0, 11, "abcdefghij", 0, 10);
     test(S("abcdefghij"), 0, 11, "abcdefghij", 1, 9);
     test(S("abcdefghij"), 0, 11, "abcdefghij", 5, 5);
     test(S("abcdefghij"), 0, 11, "abcdefghij", 9, 1);
     test(S("abcdefghij"), 0, 11, "abcdefghij", 10, 0);
TEST_CONSTEXPR_CXX20 void test5()
     test(S("abcdefghij"), 1, 10, "abcde", 2, 1);
     test(S("abcdefghij"), 1, 10, "abcde", 4, 1);
     test(S("abcdefghij"), 1, 10, "abcde", 5, 1);
     test(S("abcdefghij"), 1, 10, "abcdefghij", 0, 9);
     test(S("abcdefghij"), 1, 10, "abcdefghij", 1, 1);
 }
 
 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);
     test(S("abcdefghij"), 1, 10, "abcdefghij", 10, 1);
     test(S("abcdefghij"), 1, 10, "abcdefghijklmnopqrst", 0, 9);
     test(S("abcdefghij"), 1, 10, "abcdefghijklmnopqrst", 1, 1);
     test(S("abcdefghij"), 1, 10, "abcdefghijklmnopqrst", 10, 1);
     test(S("abcdefghij"), 1, 10, "abcdefghijklmnopqrst", 19, 1);
TEST_CONSTEXPR_CXX20 void test6()
     test(S("abcdefghij"), 5, 6, "abcdefghij", 1, 5);
     test(S("abcdefghij"), 5, 6, "abcdefghij", 5, 5);
     test(S("abcdefghij"), 5, 6, "abcdefghij", 9, 5);
     test(S("abcdefghij"), 5, 6, "abcdefghij", 10, 5);
     test(S("abcdefghij"), 5, 6, "abcdefghijklmnopqrst", 0, 5);
 }
 
 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);
     test(S("abcdefghij"), 5, 6, "abcdefghijklmnopqrst", 19, 5);
     test(S("abcdefghij"), 5, 6, "abcdefghijklmnopqrst", 20, 5);
     test(S("abcdefghij"), 9, 0, "", 0, 0);
     test(S("abcdefghij"), 9, 0, "abcde", 0, 0);
     test(S("abcdefghij"), 9, 0, "abcde", 1, -1);
TEST_CONSTEXPR_CXX20 void test7()
     test(S("abcdefghij"), 11, 0, "abcdefghijklmnopqrst", 0, 0);
     test(S("abcdefghij"), 11, 0, "abcdefghijklmnopqrst", 1, 0);
     test(S("abcdefghij"), 11, 0, "abcdefghijklmnopqrst", 10, 0);
     test(S("abcdefghij"), 11, 0, "abcdefghijklmnopqrst", 19, 0);
     test(S("abcdefghij"), 11, 0, "abcdefghijklmnopqrst", 20, 0);
 }
 
 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);
     test(S("abcdefghijklmnopqrst"), 0, 0, "abcde", 1, -1);
     test(S("abcdefghijklmnopqrst"), 0, 0, "abcde", 2, -2);
     test(S("abcdefghijklmnopqrst"), 0, 0, "abcde", 4, -4);
     test(S("abcdefghijklmnopqrst"), 0, 0, "abcde", 5, -5);
     test(S("abcdefghijklmnopqrst"), 0, 0, "abcdefghij", 0, 0);
TEST_CONSTEXPR_CXX20 void test8()
     test(S("abcdefghijklmnopqrst"), 0, 21, "abcdefghijklmnopqrst", 20, 0);
     test(S("abcdefghijklmnopqrst"), 1, 0, "", 0, 0);
     test(S("abcdefghijklmnopqrst"), 1, 0, "abcde", 0, 0);
     test(S("abcdefghijklmnopqrst"), 1, 0, "abcde", 1, -1);
     test(S("abcdefghijklmnopqrst"), 1, 0, "abcde", 2, -2);
 }
 
 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);
     test(S("abcdefghijklmnopqrst"), 1, 0, "abcdefghij", 0, 0);
     test(S("abcdefghijklmnopqrst"), 1, 0, "abcdefghij", 1, -1);
     test(S("abcdefghijklmnopqrst"), 1, 0, "abcdefghij", 5, -5);
     test(S("abcdefghijklmnopqrst"), 1, 0, "abcdefghij", 9, -9);
     test(S("abcdefghijklmnopqrst"), 1, 0, "abcdefghij", 10, -10);
TEST_CONSTEXPR_CXX20 void test9()
     test(S("abcdefghijklmnopqrst"), 10, 0, "abcde", 2, -2);
     test(S("abcdefghijklmnopqrst"), 10, 0, "abcde", 4, -4);
     test(S("abcdefghijklmnopqrst"), 10, 0, "abcde", 5, -5);
     test(S("abcdefghijklmnopqrst"), 10, 0, "abcdefghij", 0, 0);
     test(S("abcdefghijklmnopqrst"), 10, 0, "abcdefghij", 1, -1);
 }
 
 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);
     test(S("abcdefghijklmnopqrst"), 10, 0, "abcdefghij", 10, -10);
     test(S("abcdefghijklmnopqrst"), 10, 0, "abcdefghijklmnopqrst", 0, 0);
     test(S("abcdefghijklmnopqrst"), 10, 0, "abcdefghijklmnopqrst", 1, -1);
     test(S("abcdefghijklmnopqrst"), 10, 0, "abcdefghijklmnopqrst", 10, -10);
     test(S("abcdefghijklmnopqrst"), 10, 0, "abcdefghijklmnopqrst", 19, -19);
TEST_CONSTEXPR_CXX20 void test10()
     test(S("abcdefghijklmnopqrst"), 19, 0, "abcdefghij", 1, -1);
     test(S("abcdefghijklmnopqrst"), 19, 0, "abcdefghij", 5, -5);
     test(S("abcdefghijklmnopqrst"), 19, 0, "abcdefghij", 9, -9);
     test(S("abcdefghijklmnopqrst"), 19, 0, "abcdefghij", 10, -10);
     test(S("abcdefghijklmnopqrst"), 19, 0, "abcdefghijklmnopqrst", 0, 0);
 }
 
 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);
     test(S("abcdefghijklmnopqrst"), 19, 0, "abcdefghijklmnopqrst", 19, -19);
     test(S("abcdefghijklmnopqrst"), 19, 0, "abcdefghijklmnopqrst", 20, -20);
     test(S("abcdefghijklmnopqrst"), 19, 1, "", 0, 1);
     test(S("abcdefghijklmnopqrst"), 19, 1, "abcde", 0, 1);
     test(S("abcdefghijklmnopqrst"), 19, 1, "abcde", 1, 19);
TEST_CONSTEXPR_CXX20 void test11()
     test(S("abcdefghijklmnopqrst"), 21, 0, "abcdefghij", 1, 0);
     test(S("abcdefghijklmnopqrst"), 21, 0, "abcdefghij", 5, 0);
     test(S("abcdefghijklmnopqrst"), 21, 0, "abcdefghij", 9, 0);
     test(S("abcdefghijklmnopqrst"), 21, 0, "abcdefghij", 10, 0);
     test(S("abcdefghijklmnopqrst"), 21, 0, "abcdefghijklmnopqrst", 0, 0);
     test(S("abcdefghijklmnopqrst"), 21, 0, "abcdefghijklmnopqrst", 1, 0);
     test(S("abcdefghijklmnopqrst"), 21, 0, "abcdefghijklmnopqrst", 10, 0);
     test(S("abcdefghijklmnopqrst"), 21, 0, "abcdefghijklmnopqrst", 19, 0);
     test(S("abcdefghijklmnopqrst"), 21, 0, "abcdefghijklmnopqrst", 20, 0);
 }
 
-int main(int, char**)
-{
+TEST_CONSTEXPR_CXX20 bool test() {
     {
     typedef std::string S;
     test0<S>();
     test1<S>();
     test2<S>();
     test3<S>();
     test4<S>();
     test5<S>();
#if TEST_STD_VER >= 11
     test6<S>();
     test7<S>();
     test8<S>();
     test9<S>();
     test10<S>();
     test11<S>();
     }
 #endif
     
+  return true;
+}
+
+int main(int, char**) {
+  test();
+#if TEST_STD_VER > 17
+  static_assert(test());
+#endif
+
   return 0;
 }

libcxx/test/std/strings/basic.string/string.ops/string_compare/size_size_string_size_size.pass.cpp

 #include <string>
 #include <stdexcept>
 #include <cassert>
 
 #include "min_allocator.h"
 
 #include "test_macros.h"
 
-int sign(int x)
+TEST_CONSTEXPR_CXX20 int sign(int x)
 {
     if (x == 0)
         return 0;
     if (x < 0)
         return -1;
     return 1;
 }
 
 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
         {
             TEST_IGNORE_NODISCARD s.compare(pos1, n1, str, pos2, n2);
             assert(false);
         }
         catch (const std::out_of_range&)
         {
             assert(pos1 > s.size() || pos2 > str.size());
         }
     }
 #endif
 }
 
 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)
 {
     if (pos1 <= s.size() && pos2 <= str.size())
         assert(sign(s.compare(pos1, n1, str, pos2)) == sign(x));
 #ifndef TEST_HAS_NO_EXCEPTIONS
     else
     {
         try
         {
             TEST_IGNORE_NODISCARD s.compare(pos1, n1, str, pos2);
             assert(false);
         }
         catch (const std::out_of_range&)
         {
             assert(pos1 > s.size() || pos2 > str.size());
         }
     }
 #endif
 }
 
 template <class S>
-void test0()
+TEST_CONSTEXPR_CXX20 bool test0()
 {
     test(S(""), 0, 0, S(""), 0, 0, 0);
     test(S(""), 0, 0, S(""), 0, 1, 0);
     test(S(""), 0, 0, S(""), 1, 0, 0);
     test(S(""), 0, 0, S("abcde"), 0, 0, 0);
     test(S(""), 0, 0, S("abcde"), 0, 1, -1);
     test(S(""), 0, 0, S("abcde"), 0, 2, -2);
     test(S(""), 0, 0, S("abcde"), 0, 4, -4);
TEST_CONSTEXPR_CXX20 bool test0()
     test(S(""), 0, 1, S("abcde"), 2, 3, -3);
     test(S(""), 0, 1, S("abcde"), 2, 4, -3);
     test(S(""), 0, 1, S("abcde"), 4, 0, 0);
     test(S(""), 0, 1, S("abcde"), 4, 1, -1);
     test(S(""), 0, 1, S("abcde"), 4, 2, -1);
     test(S(""), 0, 1, S("abcde"), 5, 0, 0);
     test(S(""), 0, 1, S("abcde"), 5, 1, 0);
     test(S(""), 0, 1, S("abcde"), 6, 0, 0);
+
+    return true;
 }
 
 template <class S>
-void test1()
+TEST_CONSTEXPR_CXX20 bool test1()
 {
     test(S(""), 0, 1, S("abcdefghij"), 0, 0, 0);
     test(S(""), 0, 1, S("abcdefghij"), 0, 1, -1);
     test(S(""), 0, 1, S("abcdefghij"), 0, 5, -5);
     test(S(""), 0, 1, S("abcdefghij"), 0, 9, -9);
     test(S(""), 0, 1, S("abcdefghij"), 0, 10, -10);
     test(S(""), 0, 1, S("abcdefghij"), 0, 11, -10);
     test(S(""), 0, 1, S("abcdefghij"), 1, 0, 0);
TEST_CONSTEXPR_CXX20 bool test1()
     test(S(""), 1, 0, S("abcdefghij"), 9, 0, 0);
     test(S(""), 1, 0, S("abcdefghij"), 9, 1, 0);
     test(S(""), 1, 0, S("abcdefghij"), 9, 2, 0);
     test(S(""), 1, 0, S("abcdefghij"), 10, 0, 0);
     test(S(""), 1, 0, S("abcdefghij"), 10, 1, 0);
     test(S(""), 1, 0, S("abcdefghij"), 11, 0, 0);
     test(S(""), 1, 0, S("abcdefghijklmnopqrst"), 0, 0, 0);
     test(S(""), 1, 0, S("abcdefghijklmnopqrst"), 0, 1, 0);
+
+    return true;
 }
 
 template <class S>
-void test2()
+TEST_CONSTEXPR_CXX20 bool test2()
 {
     test(S(""), 1, 0, S("abcdefghijklmnopqrst"), 0, 10, 0);
     test(S(""), 1, 0, S("abcdefghijklmnopqrst"), 0, 19, 0);
     test(S(""), 1, 0, S("abcdefghijklmnopqrst"), 0, 20, 0);
     test(S(""), 1, 0, S("abcdefghijklmnopqrst"), 0, 21, 0);
     test(S(""), 1, 0, S("abcdefghijklmnopqrst"), 1, 0, 0);
     test(S(""), 1, 0, S("abcdefghijklmnopqrst"), 1, 1, 0);
     test(S(""), 1, 0, S("abcdefghijklmnopqrst"), 1, 9, 0);
TEST_CONSTEXPR_CXX20 bool test2()
     test(S("abcde"), 0, 0, S("abcdefghijklmnopqrst"), 19, 2, -1);
     test(S("abcde"), 0, 0, S("abcdefghijklmnopqrst"), 20, 0, 0);
     test(S("abcde"), 0, 0, S("abcdefghijklmnopqrst"), 20, 1, 0);
     test(S("abcde"), 0, 0, S("abcdefghijklmnopqrst"), 21, 0, 0);
     test(S("abcde"), 0, 1, S(""), 0, 0, 1);
     test(S("abcde"), 0, 1, S(""), 0, 1, 1);
     test(S("abcde"), 0, 1, S(""), 1, 0, 0);
     test(S("abcde"), 0, 1, S("abcde"), 0, 0, 1);
+
+    return true;
 }
 
 template <class S>
-void test3()
+TEST_CONSTEXPR_CXX20 bool test3()
 {
     test(S("abcde"), 0, 1, S("abcde"), 0, 1, 0);
     test(S("abcde"), 0, 1, S("abcde"), 0, 2, -1);
     test(S("abcde"), 0, 1, S("abcde"), 0, 4, -3);
     test(S("abcde"), 0, 1, S("abcde"), 0, 5, -4);
     test(S("abcde"), 0, 1, S("abcde"), 0, 6, -4);
     test(S("abcde"), 0, 1, S("abcde"), 1, 0, 1);
     test(S("abcde"), 0, 1, S("abcde"), 1, 1, -1);
TEST_CONSTEXPR_CXX20 bool test3()
     test(S("abcde"), 0, 2, S("abcde"), 4, 2, -4);
     test(S("abcde"), 0, 2, S("abcde"), 5, 0, 2);
     test(S("abcde"), 0, 2, S("abcde"), 5, 1, 2);
     test(S("abcde"), 0, 2, S("abcde"), 6, 0, 0);
     test(S("abcde"), 0, 2, S("abcdefghij"), 0, 0, 2);
     test(S("abcde"), 0, 2, S("abcdefghij"), 0, 1, 1);
     test(S("abcde"), 0, 2, S("abcdefghij"), 0, 5, -3);
     test(S("abcde"), 0, 2, S("abcdefghij"), 0, 9, -7);
+
+    return true;
 }
 
 template <class S>
-void test4()
+TEST_CONSTEXPR_CXX20 bool test4()
 {
     test(S("abcde"), 0, 2, S("abcdefghij"), 0, 10, -8);
     test(S("abcde"), 0, 2, S("abcdefghij"), 0, 11, -8);
     test(S("abcde"), 0, 2, S("abcdefghij"), 1, 0, 2);
     test(S("abcde"), 0, 2, S("abcdefghij"), 1, 1, -1);
     test(S("abcde"), 0, 2, S("abcdefghij"), 1, 4, -1);
     test(S("abcde"), 0, 2, S("abcdefghij"), 1, 8, -1);
     test(S("abcde"), 0, 2, S("abcdefghij"), 1, 9, -1);
TEST_CONSTEXPR_CXX20 bool test4()
     test(S("abcde"), 0, 4, S("abcdefghij"), 10, 1, 4);
     test(S("abcde"), 0, 4, S("abcdefghij"), 11, 0, 0);
     test(S("abcde"), 0, 4, S("abcdefghijklmnopqrst"), 0, 0, 4);
     test(S("abcde"), 0, 4, S("abcdefghijklmnopqrst"), 0, 1, 3);
     test(S("abcde"), 0, 4, S("abcdefghijklmnopqrst"), 0, 10, -6);
     test(S("abcde"), 0, 4, S("abcdefghijklmnopqrst"), 0, 19, -15);
     test(S("abcde"), 0, 4, S("abcdefghijklmnopqrst"), 0, 20, -16);
     test(S("abcde"), 0, 4, S("abcdefghijklmnopqrst"), 0, 21, -16);
+
+    return true;
 }
 
 template <class S>
-void test5()
+TEST_CONSTEXPR_CXX20 bool test5()
 {
     test(S("abcde"), 0, 4, S("abcdefghijklmnopqrst"), 1, 0, 4);
     test(S("abcde"), 0, 4, S("abcdefghijklmnopqrst"), 1, 1, -1);
     test(S("abcde"), 0, 4, S("abcdefghijklmnopqrst"), 1, 9, -1);
     test(S("abcde"), 0, 4, S("abcdefghijklmnopqrst"), 1, 18, -1);
     test(S("abcde"), 0, 4, S("abcdefghijklmnopqrst"), 1, 19, -1);
     test(S("abcde"), 0, 4, S("abcdefghijklmnopqrst"), 1, 20, -1);
     test(S("abcde"), 0, 4, S("abcdefghijklmnopqrst"), 10, 0, 4);
TEST_CONSTEXPR_CXX20 bool test5()
     test(S("abcde"), 0, 6, S(""), 0, 0, 5);
     test(S("abcde"), 0, 6, S(""), 0, 1, 5);
     test(S("abcde"), 0, 6, S(""), 1, 0, 0);
     test(S("abcde"), 0, 6, S("abcde"), 0, 0, 5);
     test(S("abcde"), 0, 6, S("abcde"), 0, 1, 4);
     test(S("abcde"), 0, 6, S("abcde"), 0, 2, 3);
     test(S("abcde"), 0, 6, S("abcde"), 0, 4, 1);
     test(S("abcde"), 0, 6, S("abcde"), 0, 5, 0);
+
+    return true;
 }
 
 template <class S>
-void test6()
+TEST_CONSTEXPR_CXX20 bool test6()
 {
     test(S("abcde"), 0, 6, S("abcde"), 0, 6, 0);
     test(S("abcde"), 0, 6, S("abcde"), 1, 0, 5);
     test(S("abcde"), 0, 6, S("abcde"), 1, 1, -1);
     test(S("abcde"), 0, 6, S("abcde"), 1, 2, -1);
     test(S("abcde"), 0, 6, S("abcde"), 1, 3, -1);
     test(S("abcde"), 0, 6, S("abcde"), 1, 4, -1);
     test(S("abcde"), 0, 6, S("abcde"), 1, 5, -1);
TEST_CONSTEXPR_CXX20 bool test6()
     test(S("abcde"), 1, 0, S("abcdefghij"), 0, 0, 0);
     test(S("abcde"), 1, 0, S("abcdefghij"), 0, 1, -1);
     test(S("abcde"), 1, 0, S("abcdefghij"), 0, 5, -5);
     test(S("abcde"), 1, 0, S("abcdefghij"), 0, 9, -9);
     test(S("abcde"), 1, 0, S("abcdefghij"), 0, 10, -10);
     test(S("abcde"), 1, 0, S("abcdefghij"), 0, 11, -10);
     test(S("abcde"), 1, 0, S("abcdefghij"), 1, 0, 0);
     test(S("abcde"), 1, 0, S("abcdefghij"), 1, 1, -1);
+
+    return true;
 }
 
 template <class S>
-void test7()
+TEST_CONSTEXPR_CXX20 bool test7()
 {
     test(S("abcde"), 1, 0, S("abcdefghij"), 1, 4, -4);
     test(S("abcde"), 1, 0, S("abcdefghij"), 1, 8, -8);
     test(S("abcde"), 1, 0, S("abcdefghij"), 1, 9, -9);
     test(S("abcde"), 1, 0, S("abcdefghij"), 1, 10, -9);
     test(S("abcde"), 1, 0, S("abcdefghij"), 5, 0, 0);
     test(S("abcde"), 1, 0, S("abcdefghij"), 5, 1, -1);
     test(S("abcde"), 1, 0, S("abcdefghij"), 5, 2, -2);
TEST_CONSTEXPR_CXX20 bool test7()
     test(S("abcde"), 1, 1, S("abcdefghijklmnopqrst"), 0, 10, 1);
     test(S("abcde"), 1, 1, S("abcdefghijklmnopqrst"), 0, 19, 1);
     test(S("abcde"), 1, 1, S("abcdefghijklmnopqrst"), 0, 20, 1);
     test(S("abcde"), 1, 1, S("abcdefghijklmnopqrst"), 0, 21, 1);
     test(S("abcde"), 1, 1, S("abcdefghijklmnopqrst"), 1, 0, 1);
     test(S("abcde"), 1, 1, S("abcdefghijklmnopqrst"), 1, 1, 0);
     test(S("abcde"), 1, 1, S("abcdefghijklmnopqrst"), 1, 9, -8);
     test(S("abcde"), 1, 1, S("abcdefghijklmnopqrst"), 1, 18, -17);
+
+    return true;
 }
 
 template <class S>
-void test8()
+TEST_CONSTEXPR_CXX20 bool test8()
 {
     test(S("abcde"), 1, 1, S("abcdefghijklmnopqrst"), 1, 19, -18);
     test(S("abcde"), 1, 1, S("abcdefghijklmnopqrst"), 1, 20, -18);
     test(S("abcde"), 1, 1, S("abcdefghijklmnopqrst"), 10, 0, 1);
     test(S("abcde"), 1, 1, S("abcdefghijklmnopqrst"), 10, 1, -9);
     test(S("abcde"), 1, 1, S("abcdefghijklmnopqrst"), 10, 5, -9);
     test(S("abcde"), 1, 1, S("abcdefghijklmnopqrst"), 10, 9, -9);
     test(S("abcde"), 1, 1, S("abcdefghijklmnopqrst"), 10, 10, -9);
TEST_CONSTEXPR_CXX20 bool test8()
     test(S("abcde"), 1, 3, S("abcde"), 0, 1, 1);
     test(S("abcde"), 1, 3, S("abcde"), 0, 2, 1);
     test(S("abcde"), 1, 3, S("abcde"), 0, 4, 1);
     test(S("abcde"), 1, 3, S("abcde"), 0, 5, 1);
     test(S("abcde"), 1, 3, S("abcde"), 0, 6, 1);
     test(S("abcde"), 1, 3, S("abcde"), 1, 0, 3);
     test(S("abcde"), 1, 3, S("abcde"), 1, 1, 2);
     test(S("abcde"), 1, 3, S("abcde"), 1, 2, 1);
+
+    return true;
 }
 
 template <class S>
-void test9()
+TEST_CONSTEXPR_CXX20 bool test9()
 {
     test(S("abcde"), 1, 3, S("abcde"), 1, 3, 0);
     test(S("abcde"), 1, 3, S("abcde"), 1, 4, -1);
     test(S("abcde"), 1, 3, S("abcde"), 1, 5, -1);
     test(S("abcde"), 1, 3, S("abcde"), 2, 0, 3);
     test(S("abcde"), 1, 3, S("abcde"), 2, 1, -1);
     test(S("abcde"), 1, 3, S("abcde"), 2, 2, -1);
     test(S("abcde"), 1, 3, S("abcde"), 2, 3, -1);
TEST_CONSTEXPR_CXX20 bool test9()
     test(S("abcde"), 1, 4, S("abcdefghij"), 0, 10, 1);
     test(S("abcde"), 1, 4, S("abcdefghij"), 0, 11, 1);
     test(S("abcde"), 1, 4, S("abcdefghij"), 1, 0, 4);
     test(S("abcde"), 1, 4, S("abcdefghij"), 1, 1, 3);
     test(S("abcde"), 1, 4, S("abcdefghij"), 1, 4, 0);
     test(S("abcde"), 1, 4, S("abcdefghij"), 1, 8, -4);
     test(S("abcde"), 1, 4, S("abcdefghij"), 1, 9, -5);
     test(S("abcde"), 1, 4, S("abcdefghij"), 1, 10, -5);
+
+    return true;
 }
 
 template <class S>
-void test10()
+TEST_CONSTEXPR_CXX20 bool test10()
 {
     test(S("abcde"), 1, 4, S("abcdefghij"), 5, 0, 4);
     test(S("abcde"), 1, 4, S("abcdefghij"), 5, 1, -4);
     test(S("abcde"), 1, 4, S("abcdefghij"), 5, 2, -4);
     test(S("abcde"), 1, 4, S("abcdefghij"), 5, 4, -4);
     test(S("abcde"), 1, 4, S("abcdefghij"), 5, 5, -4);
     test(S("abcde"), 1, 4, S("abcdefghij"), 5, 6, -4);
     test(S("abcde"), 1, 4, S("abcdefghij"), 9, 0, 4);
TEST_CONSTEXPR_CXX20 bool test10()
     test(S("abcde"), 1, 5, S("abcdefghijklmnopqrst"), 1, 0, 4);
     test(S("abcde"), 1, 5, S("abcdefghijklmnopqrst"), 1, 1, 3);
     test(S("abcde"), 1, 5, S("abcdefghijklmnopqrst"), 1, 9, -5);
     test(S("abcde"), 1, 5, S("abcdefghijklmnopqrst"), 1, 18, -14);
     test(S("abcde"), 1, 5, S("abcdefghijklmnopqrst"), 1, 19, -15);
     test(S("abcde"), 1, 5, S("abcdefghijklmnopqrst"), 1, 20, -15);
     test(S("abcde"), 1, 5, S("abcdefghijklmnopqrst"), 10, 0, 4);
     test(S("abcde"), 1, 5, S("abcdefghijklmnopqrst"), 10, 1, -9);
+
+    return true;
 }
 
 template <class S>
-void test11()
+TEST_CONSTEXPR_CXX20 bool test11()
 {
     test(S("abcde"), 1, 5, S("abcdefghijklmnopqrst"), 10, 5, -9);
     test(S("abcde"), 1, 5, S("abcdefghijklmnopqrst"), 10, 9, -9);
     test(S("abcde"), 1, 5, S("abcdefghijklmnopqrst"), 10, 10, -9);
     test(S("abcde"), 1, 5, S("abcdefghijklmnopqrst"), 10, 11, -9);
     test(S("abcde"), 1, 5, S("abcdefghijklmnopqrst"), 19, 0, 4);
     test(S("abcde"), 1, 5, S("abcdefghijklmnopqrst"), 19, 1, -18);
     test(S("abcde"), 1, 5, S("abcdefghijklmnopqrst"), 19, 2, -18);
TEST_CONSTEXPR_CXX20 bool test11()
     test(S("abcde"), 2, 1, S("abcde"), 0, 6, 2);
     test(S("abcde"), 2, 1, S("abcde"), 1, 0, 1);
     test(S("abcde"), 2, 1, S("abcde"), 1, 1, 1);
     test(S("abcde"), 2, 1, S("abcde"), 1, 2, 1);
     test(S("abcde"), 2, 1, S("abcde"), 1, 3, 1);
     test(S("abcde"), 2, 1, S("abcde"), 1, 4, 1);
     test(S("abcde"), 2, 1, S("abcde"), 1, 5, 1);
     test(S("abcde"), 2, 1, S("abcde"), 2, 0, 1);
+
+    return true;
 }
 
 template <class S>
-void test12()
+TEST_CONSTEXPR_CXX20 bool test12()
 {
     test(S("abcde"), 2, 1, S("abcde"), 2, 1, 0);
     test(S("abcde"), 2, 1, S("abcde"), 2, 2, -1);
     test(S("abcde"), 2, 1, S("abcde"), 2, 3, -2);
     test(S("abcde"), 2, 1, S("abcde"), 2, 4, -2);
     test(S("abcde"), 2, 1, S("abcde"), 4, 0, 1);
     test(S("abcde"), 2, 1, S("abcde"), 4, 1, -2);
     test(S("abcde"), 2, 1, S("abcde"), 4, 2, -2);
TEST_CONSTEXPR_CXX20 bool test12()
     test(S("abcde"), 2, 2, S("abcdefghij"), 1, 4, 1);
     test(S("abcde"), 2, 2, S("abcdefghij"), 1, 8, 1);
     test(S("abcde"), 2, 2, S("abcdefghij"), 1, 9, 1);
     test(S("abcde"), 2, 2, S("abcdefghij"), 1, 10, 1);
     test(S("abcde"), 2, 2, S("abcdefghij"), 5, 0, 2);
     test(S("abcde"), 2, 2, S("abcdefghij"), 5, 1, -3);
     test(S("abcde"), 2, 2, S("abcdefghij"), 5, 2, -3);
     test(S("abcde"), 2, 2, S("abcdefghij"), 5, 4, -3);
+
+    return true;
 }
 
 template <class S>
-void test13()
+TEST_CONSTEXPR_CXX20 bool test13()
 {
     test(S("abcde"), 2, 2, S("abcdefghij"), 5, 5, -3);
     test(S("abcde"), 2, 2, S("abcdefghij"), 5, 6, -3);
     test(S("abcde"), 2, 2, S("abcdefghij"), 9, 0, 2);
     test(S("abcde"), 2, 2, S("abcdefghij"), 9, 1, -7);
     test(S("abcde"), 2, 2, S("abcdefghij"), 9, 2, -7);
     test(S("abcde"), 2, 2, S("abcdefghij"), 10, 0, 2);
     test(S("abcde"), 2, 2, S("abcdefghij"), 10, 1, 2);
TEST_CONSTEXPR_CXX20 bool test13()
     test(S("abcde"), 2, 3, S("abcdefghijklmnopqrst"), 1, 19, 1);
     test(S("abcde"), 2, 3, S("abcdefghijklmnopqrst"), 1, 20, 1);
     test(S("abcde"), 2, 3, S("abcdefghijklmnopqrst"), 10, 0, 3);
     test(S("abcde"), 2, 3, S("abcdefghijklmnopqrst"), 10, 1, -8);
     test(S("abcde"), 2, 3, S("abcdefghijklmnopqrst"), 10, 5, -8);
     test(S("abcde"), 2, 3, S("abcdefghijklmnopqrst"), 10, 9, -8);
     test(S("abcde"), 2, 3, S("abcdefghijklmnopqrst"), 10, 10, -8);
     test(S("abcde"), 2, 3, S("abcdefghijklmnopqrst"), 10, 11, -8);
+
+    return true;
 }
 
 template <class S>
-void test14()
+TEST_CONSTEXPR_CXX20 bool test14()
 {
     test(S("abcde"), 2, 3, S("abcdefghijklmnopqrst"), 19, 0, 3);
     test(S("abcde"), 2, 3, S("abcdefghijklmnopqrst"), 19, 1, -17);
     test(S("abcde"), 2, 3, S("abcdefghijklmnopqrst"), 19, 2, -17);
     test(S("abcde"), 2, 3, S("abcdefghijklmnopqrst"), 20, 0, 3);
     test(S("abcde"), 2, 3, S("abcdefghijklmnopqrst"), 20, 1, 3);
     test(S("abcde"), 2, 3, S("abcdefghijklmnopqrst"), 21, 0, 0);
     test(S("abcde"), 2, 4, S(""), 0, 0, 3);
TEST_CONSTEXPR_CXX20 bool test14()
     test(S("abcde"), 4, 0, S("abcde"), 1, 3, -3);
     test(S("abcde"), 4, 0, S("abcde"), 1, 4, -4);
     test(S("abcde"), 4, 0, S("abcde"), 1, 5, -4);
     test(S("abcde"), 4, 0, S("abcde"), 2, 0, 0);
     test(S("abcde"), 4, 0, S("abcde"), 2, 1, -1);
     test(S("abcde"), 4, 0, S("abcde"), 2, 2, -2);
     test(S("abcde"), 4, 0, S("abcde"), 2, 3, -3);
     test(S("abcde"), 4, 0, S("abcde"), 2, 4, -3);
+
+    return true;
 }
 
 template <class S>
-void test15()
+TEST_CONSTEXPR_CXX20 bool test15()
 {
     test(S("abcde"), 4, 0, S("abcde"), 4, 0, 0);
     test(S("abcde"), 4, 0, S("abcde"), 4, 1, -1);
     test(S("abcde"), 4, 0, S("abcde"), 4, 2, -1);
     test(S("abcde"), 4, 0, S("abcde"), 5, 0, 0);
     test(S("abcde"), 4, 0, S("abcde"), 5, 1, 0);
     test(S("abcde"), 4, 0, S("abcde"), 6, 0, 0);
     test(S("abcde"), 4, 0, S("abcdefghij"), 0, 0, 0);
TEST_CONSTEXPR_CXX20 bool test15()
     test(S("abcde"), 4, 1, S("abcdefghij"), 5, 0, 1);
     test(S("abcde"), 4, 1, S("abcdefghij"), 5, 1, -1);
     test(S("abcde"), 4, 1, S("abcdefghij"), 5, 2, -1);
     test(S("abcde"), 4, 1, S("abcdefghij"), 5, 4, -1);
     test(S("abcde"), 4, 1, S("abcdefghij"), 5, 5, -1);
     test(S("abcde"), 4, 1, S("abcdefghij"), 5, 6, -1);
     test(S("abcde"), 4, 1, S("abcdefghij"), 9, 0, 1);
     test(S("abcde"), 4, 1, S("abcdefghij"), 9, 1, -5);
+
+    return true;
 }
 
 template <class S>
-void test16()
+TEST_CONSTEXPR_CXX20 bool test16()
 {
     test(S("abcde"), 4, 1, S("abcdefghij"), 9, 2, -5);
     test(S("abcde"), 4, 1, S("abcdefghij"), 10, 0, 1);
     test(S("abcde"), 4, 1, S("abcdefghij"), 10, 1, 1);
     test(S("abcde"), 4, 1, S("abcdefghij"), 11, 0, 0);
     test(S("abcde"), 4, 1, S("abcdefghijklmnopqrst"), 0, 0, 1);
     test(S("abcde"), 4, 1, S("abcdefghijklmnopqrst"), 0, 1, 4);
     test(S("abcde"), 4, 1, S("abcdefghijklmnopqrst"), 0, 10, 4);
TEST_CONSTEXPR_CXX20 bool test16()
     test(S("abcde"), 4, 2, S("abcdefghijklmnopqrst"), 10, 5, -6);
     test(S("abcde"), 4, 2, S("abcdefghijklmnopqrst"), 10, 9, -6);
     test(S("abcde"), 4, 2, S("abcdefghijklmnopqrst"), 10, 10, -6);
     test(S("abcde"), 4, 2, S("abcdefghijklmnopqrst"), 10, 11, -6);
     test(S("abcde"), 4, 2, S("abcdefghijklmnopqrst"), 19, 0, 1);
     test(S("abcde"), 4, 2, S("abcdefghijklmnopqrst"), 19, 1, -15);
     test(S("abcde"), 4, 2, S("abcdefghijklmnopqrst"), 19, 2, -15);
     test(S("abcde"), 4, 2, S("abcdefghijklmnopqrst"), 20, 0, 1);
+
+    return true;
 }
 
 template <class S>
-void test17()
+TEST_CONSTEXPR_CXX20 bool test17()
 {
     test(S("abcde"), 4, 2, S("abcdefghijklmnopqrst"), 20, 1, 1);
     test(S("abcde"), 4, 2, S("abcdefghijklmnopqrst"), 21, 0, 0);
     test(S("abcde"), 5, 0, S(""), 0, 0, 0);
     test(S("abcde"), 5, 0, S(""), 0, 1, 0);
     test(S("abcde"), 5, 0, S(""), 1, 0, 0);
     test(S("abcde"), 5, 0, S("abcde"), 0, 0, 0);
     test(S("abcde"), 5, 0, S("abcde"), 0, 1, -1);
TEST_CONSTEXPR_CXX20 bool test17()
     test(S("abcde"), 5, 1, S("abcde"), 2, 1, -1);
     test(S("abcde"), 5, 1, S("abcde"), 2, 2, -2);
     test(S("abcde"), 5, 1, S("abcde"), 2, 3, -3);
     test(S("abcde"), 5, 1, S("abcde"), 2, 4, -3);
     test(S("abcde"), 5, 1, S("abcde"), 4, 0, 0);
     test(S("abcde"), 5, 1, S("abcde"), 4, 1, -1);
     test(S("abcde"), 5, 1, S("abcde"), 4, 2, -1);
     test(S("abcde"), 5, 1, S("abcde"), 5, 0, 0);
+
+    return true;
 }
 
 template <class S>
-void test18()
+TEST_CONSTEXPR_CXX20 bool test18()
 {
     test(S("abcde"), 5, 1, S("abcde"), 5, 1, 0);
     test(S("abcde"), 5, 1, S("abcde"), 6, 0, 0);
     test(S("abcde"), 5, 1, S("abcdefghij"), 0, 0, 0);
     test(S("abcde"), 5, 1, S("abcdefghij"), 0, 1, -1);
     test(S("abcde"), 5, 1, S("abcdefghij"), 0, 5, -5);
     test(S("abcde"), 5, 1, S("abcdefghij"), 0, 9, -9);
     test(S("abcde"), 5, 1, S("abcdefghij"), 0, 10, -10);
TEST_CONSTEXPR_CXX20 bool test18()
     test(S("abcde"), 6, 0, S("abcdefghij"), 5, 5, 0);
     test(S("abcde"), 6, 0, S("abcdefghij"), 5, 6, 0);
     test(S("abcde"), 6, 0, S("abcdefghij"), 9, 0, 0);
     test(S("abcde"), 6, 0, S("abcdefghij"), 9, 1, 0);
     test(S("abcde"), 6, 0, S("abcdefghij"), 9, 2, 0);
     test(S("abcde"), 6, 0, S("abcdefghij"), 10, 0, 0);
     test(S("abcde"), 6, 0, S("abcdefghij"), 10, 1, 0);
     test(S("abcde"), 6, 0, S("abcdefghij"), 11, 0, 0);
+
+    return true;
 }
 
 template <class S>
-void test19()
+TEST_CONSTEXPR_CXX20 bool test19()
 {
     test(S("abcde"), 6, 0, S("abcdefghijklmnopqrst"), 0, 0, 0);
     test(S("abcde"), 6, 0, S("abcdefghijklmnopqrst"), 0, 1, 0);
     test(S("abcde"), 6, 0, S("abcdefghijklmnopqrst"), 0, 10, 0);
     test(S("abcde"), 6, 0, S("abcdefghijklmnopqrst"), 0, 19, 0);
     test(S("abcde"), 6, 0, S("abcdefghijklmnopqrst"), 0, 20, 0);
     test(S("abcde"), 6, 0, S("abcdefghijklmnopqrst"), 0, 21, 0);
     test(S("abcde"), 6, 0, S("abcdefghijklmnopqrst"), 1, 0, 0);
TEST_CONSTEXPR_CXX20 bool test19()
     test(S("abcdefghij"), 0, 0, S("abcdefghijklmnopqrst"), 19, 0, 0);
     test(S("abcdefghij"), 0, 0, S("abcdefghijklmnopqrst"), 19, 1, -1);
     test(S("abcdefghij"), 0, 0, S("abcdefghijklmnopqrst"), 19, 2, -1);
     test(S("abcdefghij"), 0, 0, S("abcdefghijklmnopqrst"), 20, 0, 0);
     test(S("abcdefghij"), 0, 0, S("abcdefghijklmnopqrst"), 20, 1, 0);
     test(S("abcdefghij"), 0, 0, S("abcdefghijklmnopqrst"), 21, 0, 0);
     test(S("abcdefghij"), 0, 1, S(""), 0, 0, 1);
     test(S("abcdefghij"), 0, 1, S(""), 0, 1, 1);
+
+    return true;
 }
 
 template <class S>
-void test20()
+TEST_CONSTEXPR_CXX20 bool test20()
 {
     test(S("abcdefghij"), 0, 1, S(""), 1, 0, 0);
     test(S("abcdefghij"), 0, 1, S("abcde"), 0, 0, 1);
     test(S("abcdefghij"), 0, 1, S("abcde"), 0, 1, 0);
     test(S("abcdefghij"), 0, 1, S("abcde"), 0, 2, -1);
     test(S("abcdefghij"), 0, 1, S("abcde"), 0, 4, -3);
     test(S("abcdefghij"), 0, 1, S("abcde"), 0, 5, -4);
     test(S("abcdefghij"), 0, 1, S("abcde"), 0, 6, -4);
TEST_CONSTEXPR_CXX20 bool test20()
     test(S("abcdefghij"), 0, 5, S("abcde"), 4, 0, 5);
     test(S("abcdefghij"), 0, 5, S("abcde"), 4, 1, -4);
     test(S("abcdefghij"), 0, 5, S("abcde"), 4, 2, -4);
     test(S("abcdefghij"), 0, 5, S("abcde"), 5, 0, 5);
     test(S("abcdefghij"), 0, 5, S("abcde"), 5, 1, 5);
     test(S("abcdefghij"), 0, 5, S("abcde"), 6, 0, 0);
     test(S("abcdefghij"), 0, 5, S("abcdefghij"), 0, 0, 5);
     test(S("abcdefghij"), 0, 5, S("abcdefghij"), 0, 1, 4);
+
+    return true;
 }
 
 template <class S>
-void test21()
+TEST_CONSTEXPR_CXX20 bool test21()
 {
     test(S("abcdefghij"), 0, 5, S("abcdefghij"), 0, 5, 0);
     test(S("abcdefghij"), 0, 5, S("abcdefghij"), 0, 9, -4);
     test(S("abcdefghij"), 0, 5, S("abcdefghij"), 0, 10, -5);
     test(S("abcdefghij"), 0, 5, S("abcdefghij"), 0, 11, -5);
     test(S("abcdefghij"), 0, 5, S("abcdefghij"), 1, 0, 5);
     test(S("abcdefghij"), 0, 5, S("abcdefghij"), 1, 1, -1);
     test(S("abcdefghij"), 0, 5, S("abcdefghij"), 1, 4, -1);
TEST_CONSTEXPR_CXX20 bool test21()
     test(S("abcdefghij"), 0, 9, S("abcdefghij"), 9, 2, -9);
     test(S("abcdefghij"), 0, 9, S("abcdefghij"), 10, 0, 9);
     test(S("abcdefghij"), 0, 9, S("abcdefghij"), 10, 1, 9);
     test(S("abcdefghij"), 0, 9, S("abcdefghij"), 11, 0, 0);
     test(S("abcdefghij"), 0, 9, S("abcdefghijklmnopqrst"), 0, 0, 9);
     test(S("abcdefghij"), 0, 9, S("abcdefghijklmnopqrst"), 0, 1, 8);
     test(S("abcdefghij"), 0, 9, S("abcdefghijklmnopqrst"), 0, 10, -1);
     test(S("abcdefghij"), 0, 9, S("abcdefghijklmnopqrst"), 0, 19, -10);
+
+    return true;
 }
 
 template <class S>
-void test22()
+TEST_CONSTEXPR_CXX20 bool test22()
 {
     test(S("abcdefghij"), 0, 9, S("abcdefghijklmnopqrst"), 0, 20, -11);
     test(S("abcdefghij"), 0, 9, S("abcdefghijklmnopqrst"), 0, 21, -11);
     test(S("abcdefghij"), 0, 9, S("abcdefghijklmnopqrst"), 1, 0, 9);
     test(S("abcdefghij"), 0, 9, S("abcdefghijklmnopqrst"), 1, 1, -1);
     test(S("abcdefghij"), 0, 9, S("abcdefghijklmnopqrst"), 1, 9, -1);
     test(S("abcdefghij"), 0, 9, S("abcdefghijklmnopqrst"), 1, 18, -1);
     test(S("abcdefghij"), 0, 9, S("abcdefghijklmnopqrst"), 1, 19, -1);
TEST_CONSTEXPR_CXX20 bool test22()
     test(S("abcdefghij"), 0, 10, S("abcdefghijklmnopqrst"), 20, 1, 10);
     test(S("abcdefghij"), 0, 10, S("abcdefghijklmnopqrst"), 21, 0, 0);
     test(S("abcdefghij"), 0, 11, S(""), 0, 0, 10);
     test(S("abcdefghij"), 0, 11, S(""), 0, 1, 10);
     test(S("abcdefghij"), 0, 11, S(""), 1, 0, 0);
     test(S("abcdefghij"), 0, 11, S("abcde"), 0, 0, 10);
     test(S("abcdefghij"), 0, 11, S("abcde"), 0, 1, 9);
     test(S("abcdefghij"), 0, 11, S("abcde"), 0, 2, 8);
+
+    return true;
 }
 
 template <class S>
-void test23()
+TEST_CONSTEXPR_CXX20 bool test23()
 {
     test(S("abcdefghij"), 0, 11, S("abcde"), 0, 4, 6);
     test(S("abcdefghij"), 0, 11, S("abcde"), 0, 5, 5);
     test(S("abcdefghij"), 0, 11, S("abcde"), 0, 6, 5);
     test(S("abcdefghij"), 0, 11, S("abcde"), 1, 0, 10);
     test(S("abcdefghij"), 0, 11, S("abcde"), 1, 1, -1);
     test(S("abcdefghij"), 0, 11, S("abcde"), 1, 2, -1);
     test(S("abcdefghij"), 0, 11, S("abcde"), 1, 3, -1);
TEST_CONSTEXPR_CXX20 bool test23()
     test(S("abcdefghij"), 1, 0, S("abcde"), 5, 1, 0);
     test(S("abcdefghij"), 1, 0, S("abcde"), 6, 0, 0);
     test(S("abcdefghij"), 1, 0, S("abcdefghij"), 0, 0, 0);
     test(S("abcdefghij"), 1, 0, S("abcdefghij"), 0, 1, -1);
     test(S("abcdefghij"), 1, 0, S("abcdefghij"), 0, 5, -5);
     test(S("abcdefghij"), 1, 0, S("abcdefghij"), 0, 9, -9);
     test(S("abcdefghij"), 1, 0, S("abcdefghij"), 0, 10, -10);
     test(S("abcdefghij"), 1, 0, S("abcdefghij"), 0, 11, -10);
+
+    return true;
 }
 
 template <class S>
-void test24()
+TEST_CONSTEXPR_CXX20 bool test24()
 {
     test(S("abcdefghij"), 1, 0, S("abcdefghij"), 1, 0, 0);
     test(S("abcdefghij"), 1, 0, S("abcdefghij"), 1, 1, -1);
     test(S("abcdefghij"), 1, 0, S("abcdefghij"), 1, 4, -4);
     test(S("abcdefghij"), 1, 0, S("abcdefghij"), 1, 8, -8);
     test(S("abcdefghij"), 1, 0, S("abcdefghij"), 1, 9, -9);
     test(S("abcdefghij"), 1, 0, S("abcdefghij"), 1, 10, -9);
     test(S("abcdefghij"), 1, 0, S("abcdefghij"), 5, 0, 0);
TEST_CONSTEXPR_CXX20 bool test24()
     test(S("abcdefghij"), 1, 1, S("abcdefghijklmnopqrst"), 0, 0, 1);
     test(S("abcdefghij"), 1, 1, S("abcdefghijklmnopqrst"), 0, 1, 1);
     test(S("abcdefghij"), 1, 1, S("abcdefghijklmnopqrst"), 0, 10, 1);
     test(S("abcdefghij"), 1, 1, S("abcdefghijklmnopqrst"), 0, 19, 1);
     test(S("abcdefghij"), 1, 1, S("abcdefghijklmnopqrst"), 0, 20, 1);
     test(S("abcdefghij"), 1, 1, S("abcdefghijklmnopqrst"), 0, 21, 1);
     test(S("abcdefghij"), 1, 1, S("abcdefghijklmnopqrst"), 1, 0, 1);
     test(S("abcdefghij"), 1, 1, S("abcdefghijklmnopqrst"), 1, 1, 0);
+
+    return true;
 }
 
 template <class S>
-void test25()
+TEST_CONSTEXPR_CXX20 bool test25()
 {
     test(S("abcdefghij"), 1, 1, S("abcdefghijklmnopqrst"), 1, 9, -8);
     test(S("abcdefghij"), 1, 1, S("abcdefghijklmnopqrst"), 1, 18, -17);
     test(S("abcdefghij"), 1, 1, S("abcdefghijklmnopqrst"), 1, 19, -18);
     test(S("abcdefghij"), 1, 1, S("abcdefghijklmnopqrst"), 1, 20, -18);
     test(S("abcdefghij"), 1, 1, S("abcdefghijklmnopqrst"), 10, 0, 1);
     test(S("abcdefghij"), 1, 1, S("abcdefghijklmnopqrst"), 10, 1, -9);
     test(S("abcdefghij"), 1, 1, S("abcdefghijklmnopqrst"), 10, 5, -9);
TEST_CONSTEXPR_CXX20 bool test25()
     test(S("abcdefghij"), 1, 8, S(""), 1, 0, 0);
     test(S("abcdefghij"), 1, 8, S("abcde"), 0, 0, 8);
     test(S("abcdefghij"), 1, 8, S("abcde"), 0, 1, 1);
     test(S("abcdefghij"), 1, 8, S("abcde"), 0, 2, 1);
     test(S("abcdefghij"), 1, 8, S("abcde"), 0, 4, 1);
     test(S("abcdefghij"), 1, 8, S("abcde"), 0, 5, 1);
     test(S("abcdefghij"), 1, 8, S("abcde"), 0, 6, 1);
     test(S("abcdefghij"), 1, 8, S("abcde"), 1, 0, 8);
+
+    return true;
 }
 
 template <class S>
-void test26()
+TEST_CONSTEXPR_CXX20 bool test26()
 {
     test(S("abcdefghij"), 1, 8, S("abcde"), 1, 1, 7);
     test(S("abcdefghij"), 1, 8, S("abcde"), 1, 2, 6);
     test(S("abcdefghij"), 1, 8, S("abcde"), 1, 3, 5);
     test(S("abcdefghij"), 1, 8, S("abcde"), 1, 4, 4);
     test(S("abcdefghij"), 1, 8, S("abcde"), 1, 5, 4);
     test(S("abcdefghij"), 1, 8, S("abcde"), 2, 0, 8);
     test(S("abcdefghij"), 1, 8, S("abcde"), 2, 1, -1);
TEST_CONSTEXPR_CXX20 bool test26()
     test(S("abcdefghij"), 1, 9, S("abcdefghij"), 0, 5, 1);
     test(S("abcdefghij"), 1, 9, S("abcdefghij"), 0, 9, 1);
     test(S("abcdefghij"), 1, 9, S("abcdefghij"), 0, 10, 1);
     test(S("abcdefghij"), 1, 9, S("abcdefghij"), 0, 11, 1);
     test(S("abcdefghij"), 1, 9, S("abcdefghij"), 1, 0, 9);
     test(S("abcdefghij"), 1, 9, S("abcdefghij"), 1, 1, 8);
     test(S("abcdefghij"), 1, 9, S("abcdefghij"), 1, 4, 5);
     test(S("abcdefghij"), 1, 9, S("abcdefghij"), 1, 8, 1);
+
+    return true;
 }
 
 template <class S>
-void test27()
+TEST_CONSTEXPR_CXX20 bool test27()
 {
     test(S("abcdefghij"), 1, 9, S("abcdefghij"), 1, 9, 0);
     test(S("abcdefghij"), 1, 9, S("abcdefghij"), 1, 10, 0);
     test(S("abcdefghij"), 1, 9, S("abcdefghij"), 5, 0, 9);
     test(S("abcdefghij"), 1, 9, S("abcdefghij"), 5, 1, -4);
     test(S("abcdefghij"), 1, 9, S("abcdefghij"), 5, 2, -4);
     test(S("abcdefghij"), 1, 9, S("abcdefghij"), 5, 4, -4);
     test(S("abcdefghij"), 1, 9, S("abcdefghij"), 5, 5, -4);
TEST_CONSTEXPR_CXX20 bool test27()
     test(S("abcdefghij"), 1, 10, S("abcdefghijklmnopqrst"), 0, 20, 1);
     test(S("abcdefghij"), 1, 10, S("abcdefghijklmnopqrst"), 0, 21, 1);
     test(S("abcdefghij"), 1, 10, S("abcdefghijklmnopqrst"), 1, 0, 9);
     test(S("abcdefghij"), 1, 10, S("abcdefghijklmnopqrst"), 1, 1, 8);
     test(S("abcdefghij"), 1, 10, S("abcdefghijklmnopqrst"), 1, 9, 0);
     test(S("abcdefghij"), 1, 10, S("abcdefghijklmnopqrst"), 1, 18, -9);
     test(S("abcdefghij"), 1, 10, S("abcdefghijklmnopqrst"), 1, 19, -10);
     test(S("abcdefghij"), 1, 10, S("abcdefghijklmnopqrst"), 1, 20, -10);
+
+    return true;
 }
 
 template <class S>
-void test28()
+TEST_CONSTEXPR_CXX20 bool test28()
 {
     test(S("abcdefghij"), 1, 10, S("abcdefghijklmnopqrst"), 10, 0, 9);
     test(S("abcdefghij"), 1, 10, S("abcdefghijklmnopqrst"), 10, 1, -9);
     test(S("abcdefghij"), 1, 10, S("abcdefghijklmnopqrst"), 10, 5, -9);
     test(S("abcdefghij"), 1, 10, S("abcdefghijklmnopqrst"), 10, 9, -9);
     test(S("abcdefghij"), 1, 10, S("abcdefghijklmnopqrst"), 10, 10, -9);
     test(S("abcdefghij"), 1, 10, S("abcdefghijklmnopqrst"), 10, 11, -9);
     test(S("abcdefghij"), 1, 10, S("abcdefghijklmnopqrst"), 19, 0, 9);
TEST_CONSTEXPR_CXX20 bool test28()
     test(S("abcdefghij"), 5, 1, S("abcde"), 0, 4, 5);
     test(S("abcdefghij"), 5, 1, S("abcde"), 0, 5, 5);
     test(S("abcdefghij"), 5, 1, S("abcde"), 0, 6, 5);
     test(S("abcdefghij"), 5, 1, S("abcde"), 1, 0, 1);
     test(S("abcdefghij"), 5, 1, S("abcde"), 1, 1, 4);
     test(S("abcdefghij"), 5, 1, S("abcde"), 1, 2, 4);
     test(S("abcdefghij"), 5, 1, S("abcde"), 1, 3, 4);
     test(S("abcdefghij"), 5, 1, S("abcde"), 1, 4, 4);
+
+    return true;
 }
 
 template <class S>
-void test29()
+TEST_CONSTEXPR_CXX20 bool test29()
 {
     test(S("abcdefghij"), 5, 1, S("abcde"), 1, 5, 4);
     test(S("abcdefghij"), 5, 1, S("abcde"), 2, 0, 1);
     test(S("abcdefghij"), 5, 1, S("abcde"), 2, 1, 3);
     test(S("abcdefghij"), 5, 1, S("abcde"), 2, 2, 3);
     test(S("abcdefghij"), 5, 1, S("abcde"), 2, 3, 3);
     test(S("abcdefghij"), 5, 1, S("abcde"), 2, 4, 3);
     test(S("abcdefghij"), 5, 1, S("abcde"), 4, 0, 1);
TEST_CONSTEXPR_CXX20 bool test29()
     test(S("abcdefghij"), 5, 2, S("abcdefghij"), 1, 0, 2);
     test(S("abcdefghij"), 5, 2, S("abcdefghij"), 1, 1, 4);
     test(S("abcdefghij"), 5, 2, S("abcdefghij"), 1, 4, 4);
     test(S("abcdefghij"), 5, 2, S("abcdefghij"), 1, 8, 4);
     test(S("abcdefghij"), 5, 2, S("abcdefghij"), 1, 9, 4);
     test(S("abcdefghij"), 5, 2, S("abcdefghij"), 1, 10, 4);
     test(S("abcdefghij"), 5, 2, S("abcdefghij"), 5, 0, 2);
     test(S("abcdefghij"), 5, 2, S("abcdefghij"), 5, 1, 1);
+
+    return true;
 }
 
 template <class S>
-void test30()
+TEST_CONSTEXPR_CXX20 bool test30()
 {
     test(S("abcdefghij"), 5, 2, S("abcdefghij"), 5, 2, 0);
     test(S("abcdefghij"), 5, 2, S("abcdefghij"), 5, 4, -2);
     test(S("abcdefghij"), 5, 2, S("abcdefghij"), 5, 5, -3);
     test(S("abcdefghij"), 5, 2, S("abcdefghij"), 5, 6, -3);
     test(S("abcdefghij"), 5, 2, S("abcdefghij"), 9, 0, 2);
     test(S("abcdefghij"), 5, 2, S("abcdefghij"), 9, 1, -4);
     test(S("abcdefghij"), 5, 2, S("abcdefghij"), 9, 2, -4);
TEST_CONSTEXPR_CXX20 bool test30()
     test(S("abcdefghij"), 5, 4, S("abcdefghijklmnopqrst"), 1, 9, 4);
     test(S("abcdefghij"), 5, 4, S("abcdefghijklmnopqrst"), 1, 18, 4);
     test(S("abcdefghij"), 5, 4, S("abcdefghijklmnopqrst"), 1, 19, 4);
     test(S("abcdefghij"), 5, 4, S("abcdefghijklmnopqrst"), 1, 20, 4);
     test(S("abcdefghij"), 5, 4, S("abcdefghijklmnopqrst"), 10, 0, 4);
     test(S("abcdefghij"), 5, 4, S("abcdefghijklmnopqrst"), 10, 1, -5);
     test(S("abcdefghij"), 5, 4, S("abcdefghijklmnopqrst"), 10, 5, -5);
     test(S("abcdefghij"), 5, 4, S("abcdefghijklmnopqrst"), 10, 9, -5);
+
+    return true;
 }
 
 template <class S>
-void test31()
+TEST_CONSTEXPR_CXX20 bool test31()
 {
     test(S("abcdefghij"), 5, 4, S("abcdefghijklmnopqrst"), 10, 10, -5);
     test(S("abcdefghij"), 5, 4, S("abcdefghijklmnopqrst"), 10, 11, -5);
     test(S("abcdefghij"), 5, 4, S("abcdefghijklmnopqrst"), 19, 0, 4);
     test(S("abcdefghij"), 5, 4, S("abcdefghijklmnopqrst"), 19, 1, -14);
     test(S("abcdefghij"), 5, 4, S("abcdefghijklmnopqrst"), 19, 2, -14);
     test(S("abcdefghij"), 5, 4, S("abcdefghijklmnopqrst"), 20, 0, 4);
     test(S("abcdefghij"), 5, 4, S("abcdefghijklmnopqrst"), 20, 1, 4);
TEST_CONSTEXPR_CXX20 bool test31()
     test(S("abcdefghij"), 5, 6, S("abcde"), 1, 1, 4);
     test(S("abcdefghij"), 5, 6, S("abcde"), 1, 2, 4);
     test(S("abcdefghij"), 5, 6, S("abcde"), 1, 3, 4);
     test(S("abcdefghij"), 5, 6, S("abcde"), 1, 4, 4);
     test(S("abcdefghij"), 5, 6, S("abcde"), 1, 5, 4);
     test(S("abcdefghij"), 5, 6, S("abcde"), 2, 0, 5);
     test(S("abcdefghij"), 5, 6, S("abcde"), 2, 1, 3);
     test(S("abcdefghij"), 5, 6, S("abcde"), 2, 2, 3);
+
+    return true;
 }
 
 template <class S>
-void test32()
+TEST_CONSTEXPR_CXX20 bool test32()
 {
     test(S("abcdefghij"), 5, 6, S("abcde"), 2, 3, 3);
     test(S("abcdefghij"), 5, 6, S("abcde"), 2, 4, 3);
     test(S("abcdefghij"), 5, 6, S("abcde"), 4, 0, 5);
     test(S("abcdefghij"), 5, 6, S("abcde"), 4, 1, 1);
     test(S("abcdefghij"), 5, 6, S("abcde"), 4, 2, 1);
     test(S("abcdefghij"), 5, 6, S("abcde"), 5, 0, 5);
     test(S("abcdefghij"), 5, 6, S("abcde"), 5, 1, 5);
TEST_CONSTEXPR_CXX20 bool test32()
     test(S("abcdefghij"), 9, 0, S("abcdefghij"), 1, 9, -9);
     test(S("abcdefghij"), 9, 0, S("abcdefghij"), 1, 10, -9);
     test(S("abcdefghij"), 9, 0, S("abcdefghij"), 5, 0, 0);
     test(S("abcdefghij"), 9, 0, S("abcdefghij"), 5, 1, -1);
     test(S("abcdefghij"), 9, 0, S("abcdefghij"), 5, 2, -2);
     test(S("abcdefghij"), 9, 0, S("abcdefghij"), 5, 4, -4);
     test(S("abcdefghij"), 9, 0, S("abcdefghij"), 5, 5, -5);
     test(S("abcdefghij"), 9, 0, S("abcdefghij"), 5, 6, -5);
+
+    return true;
 }
 
 template <class S>
-void test33()
+TEST_CONSTEXPR_CXX20 bool test33()
 {
     test(S("abcdefghij"), 9, 0, S("abcdefghij"), 9, 0, 0);
     test(S("abcdefghij"), 9, 0, S("abcdefghij"), 9, 1, -1);
     test(S("abcdefghij"), 9, 0, S("abcdefghij"), 9, 2, -1);
     test(S("abcdefghij"), 9, 0, S("abcdefghij"), 10, 0, 0);
     test(S("abcdefghij"), 9, 0, S("abcdefghij"), 10, 1, 0);
     test(S("abcdefghij"), 9, 0, S("abcdefghij"), 11, 0, 0);
     test(S("abcdefghij"), 9, 0, S("abcdefghijklmnopqrst"), 0, 0, 0);
TEST_CONSTEXPR_CXX20 bool test33()
     test(S("abcdefghij"), 9, 1, S("abcdefghijklmnopqrst"), 10, 0, 1);
     test(S("abcdefghij"), 9, 1, S("abcdefghijklmnopqrst"), 10, 1, -1);
     test(S("abcdefghij"), 9, 1, S("abcdefghijklmnopqrst"), 10, 5, -1);
     test(S("abcdefghij"), 9, 1, S("abcdefghijklmnopqrst"), 10, 9, -1);
     test(S("abcdefghij"), 9, 1, S("abcdefghijklmnopqrst"), 10, 10, -1);
     test(S("abcdefghij"), 9, 1, S("abcdefghijklmnopqrst"), 10, 11, -1);
     test(S("abcdefghij"), 9, 1, S("abcdefghijklmnopqrst"), 19, 0, 1);
     test(S("abcdefghij"), 9, 1, S("abcdefghijklmnopqrst"), 19, 1, -10);
+
+    return true;
 }
 
 template <class S>
-void test34()
+TEST_CONSTEXPR_CXX20 bool test34()
 {
     test(S("abcdefghij"), 9, 1, S("abcdefghijklmnopqrst"), 19, 2, -10);
     test(S("abcdefghij"), 9, 1, S("abcdefghijklmnopqrst"), 20, 0, 1);
     test(S("abcdefghij"), 9, 1, S("abcdefghijklmnopqrst"), 20, 1, 1);
     test(S("abcdefghij"), 9, 1, S("abcdefghijklmnopqrst"), 21, 0, 0);
     test(S("abcdefghij"), 9, 2, S(""), 0, 0, 1);
     test(S("abcdefghij"), 9, 2, S(""), 0, 1, 1);
     test(S("abcdefghij"), 9, 2, S(""), 1, 0, 0);
TEST_CONSTEXPR_CXX20 bool test34()
     test(S("abcdefghij"), 10, 0, S("abcde"), 1, 5, -4);
     test(S("abcdefghij"), 10, 0, S("abcde"), 2, 0, 0);
     test(S("abcdefghij"), 10, 0, S("abcde"), 2, 1, -1);
     test(S("abcdefghij"), 10, 0, S("abcde"), 2, 2, -2);
     test(S("abcdefghij"), 10, 0, S("abcde"), 2, 3, -3);
     test(S("abcdefghij"), 10, 0, S("abcde"), 2, 4, -3);
     test(S("abcdefghij"), 10, 0, S("abcde"), 4, 0, 0);
     test(S("abcdefghij"), 10, 0, S("abcde"), 4, 1, -1);
+
+    return true;
 }
 
 template <class S>
-void test35()
+TEST_CONSTEXPR_CXX20 bool test35()
 {
     test(S("abcdefghij"), 10, 0, S("abcde"), 4, 2, -1);
     test(S("abcdefghij"), 10, 0, S("abcde"), 5, 0, 0);
     test(S("abcdefghij"), 10, 0, S("abcde"), 5, 1, 0);
     test(S("abcdefghij"), 10, 0, S("abcde"), 6, 0, 0);
     test(S("abcdefghij"), 10, 0, S("abcdefghij"), 0, 0, 0);
     test(S("abcdefghij"), 10, 0, S("abcdefghij"), 0, 1, -1);
     test(S("abcdefghij"), 10, 0, S("abcdefghij"), 0, 5, -5);
TEST_CONSTEXPR_CXX20 bool test35()
     test(S("abcdefghij"), 10, 1, S("abcdefghij"), 5, 2, -2);
     test(S("abcdefghij"), 10, 1, S("abcdefghij"), 5, 4, -4);
     test(S("abcdefghij"), 10, 1, S("abcdefghij"), 5, 5, -5);
     test(S("abcdefghij"), 10, 1, S("abcdefghij"), 5, 6, -5);
     test(S("abcdefghij"), 10, 1, S("abcdefghij"), 9, 0, 0);
     test(S("abcdefghij"), 10, 1, S("abcdefghij"), 9, 1, -1);
     test(S("abcdefghij"), 10, 1, S("abcdefghij"), 9, 2, -1);
     test(S("abcdefghij"), 10, 1, S("abcdefghij"), 10, 0, 0);
+
+    return true;
 }
 
 template <class S>
-void test36()
+TEST_CONSTEXPR_CXX20 bool test36()
 {
     test(S("abcdefghij"), 10, 1, S("abcdefghij"), 10, 1, 0);
     test(S("abcdefghij"), 10, 1, S("abcdefghij"), 11, 0, 0);
     test(S("abcdefghij"), 10, 1, S("abcdefghijklmnopqrst"), 0, 0, 0);
     test(S("abcdefghij"), 10, 1, S("abcdefghijklmnopqrst"), 0, 1, -1);
     test(S("abcdefghij"), 10, 1, S("abcdefghijklmnopqrst"), 0, 10, -10);
     test(S("abcdefghij"), 10, 1, S("abcdefghijklmnopqrst"), 0, 19, -19);
     test(S("abcdefghij"), 10, 1, S("abcdefghijklmnopqrst"), 0, 20, -20);
TEST_CONSTEXPR_CXX20 bool test36()
     test(S("abcdefghij"), 11, 0, S("abcdefghijklmnopqrst"), 10, 10, 0);
     test(S("abcdefghij"), 11, 0, S("abcdefghijklmnopqrst"), 10, 11, 0);
     test(S("abcdefghij"), 11, 0, S("abcdefghijklmnopqrst"), 19, 0, 0);
     test(S("abcdefghij"), 11, 0, S("abcdefghijklmnopqrst"), 19, 1, 0);
     test(S("abcdefghij"), 11, 0, S("abcdefghijklmnopqrst"), 19, 2, 0);
     test(S("abcdefghij"), 11, 0, S("abcdefghijklmnopqrst"), 20, 0, 0);
     test(S("abcdefghij"), 11, 0, S("abcdefghijklmnopqrst"), 20, 1, 0);
     test(S("abcdefghij"), 11, 0, S("abcdefghijklmnopqrst"), 21, 0, 0);
+
+    return true;
 }
 
 template <class S>
-void test37()
+TEST_CONSTEXPR_CXX20 bool test37()
 {
     test(S("abcdefghijklmnopqrst"), 0, 0, S(""), 0, 0, 0);
     test(S("abcdefghijklmnopqrst"), 0, 0, S(""), 0, 1, 0);
     test(S("abcdefghijklmnopqrst"), 0, 0, S(""), 1, 0, 0);
     test(S("abcdefghijklmnopqrst"), 0, 0, S("abcde"), 0, 0, 0);
     test(S("abcdefghijklmnopqrst"), 0, 0, S("abcde"), 0, 1, -1);
     test(S("abcdefghijklmnopqrst"), 0, 0, S("abcde"), 0, 2, -2);
     test(S("abcdefghijklmnopqrst"), 0, 0, S("abcde"), 0, 4, -4);
TEST_CONSTEXPR_CXX20 bool test37()
     test(S("abcdefghijklmnopqrst"), 0, 1, S("abcde"), 2, 3, -2);
     test(S("abcdefghijklmnopqrst"), 0, 1, S("abcde"), 2, 4, -2);
     test(S("abcdefghijklmnopqrst"), 0, 1, S("abcde"), 4, 0, 1);
     test(S("abcdefghijklmnopqrst"), 0, 1, S("abcde"), 4, 1, -4);
     test(S("abcdefghijklmnopqrst"), 0, 1, S("abcde"), 4, 2, -4);
     test(S("abcdefghijklmnopqrst"), 0, 1, S("abcde"), 5, 0, 1);
     test(S("abcdefghijklmnopqrst"), 0, 1, S("abcde"), 5, 1, 1);
     test(S("abcdefghijklmnopqrst"), 0, 1, S("abcde"), 6, 0, 0);
+
+    return true;
 }
 
 template <class S>
-void test38()
+TEST_CONSTEXPR_CXX20 bool test38()
 {
     test(S("abcdefghijklmnopqrst"), 0, 1, S("abcdefghij"), 0, 0, 1);
     test(S("abcdefghijklmnopqrst"), 0, 1, S("abcdefghij"), 0, 1, 0);
     test(S("abcdefghijklmnopqrst"), 0, 1, S("abcdefghij"), 0, 5, -4);
     test(S("abcdefghijklmnopqrst"), 0, 1, S("abcdefghij"), 0, 9, -8);
     test(S("abcdefghijklmnopqrst"), 0, 1, S("abcdefghij"), 0, 10, -9);
     test(S("abcdefghijklmnopqrst"), 0, 1, S("abcdefghij"), 0, 11, -9);
     test(S("abcdefghijklmnopqrst"), 0, 1, S("abcdefghij"), 1, 0, 1);
TEST_CONSTEXPR_CXX20 bool test38()
     test(S("abcdefghijklmnopqrst"), 0, 10, S("abcdefghij"), 9, 0, 10);
     test(S("abcdefghijklmnopqrst"), 0, 10, S("abcdefghij"), 9, 1, -9);
     test(S("abcdefghijklmnopqrst"), 0, 10, S("abcdefghij"), 9, 2, -9);
     test(S("abcdefghijklmnopqrst"), 0, 10, S("abcdefghij"), 10, 0, 10);
     test(S("abcdefghijklmnopqrst"), 0, 10, S("abcdefghij"), 10, 1, 10);
     test(S("abcdefghijklmnopqrst"), 0, 10, S("abcdefghij"), 11, 0, 0);
     test(S("abcdefghijklmnopqrst"), 0, 10, S("abcdefghijklmnopqrst"), 0, 0, 10);
     test(S("abcdefghijklmnopqrst"), 0, 10, S("abcdefghijklmnopqrst"), 0, 1, 9);
+
+    return true;
 }
 
 template <class S>
-void test39()
+TEST_CONSTEXPR_CXX20 bool test39()
 {
     test(S("abcdefghijklmnopqrst"), 0, 10, S("abcdefghijklmnopqrst"), 0, 10, 0);
     test(S("abcdefghijklmnopqrst"), 0, 10, S("abcdefghijklmnopqrst"), 0, 19, -9);
     test(S("abcdefghijklmnopqrst"), 0, 10, S("abcdefghijklmnopqrst"), 0, 20, -10);
     test(S("abcdefghijklmnopqrst"), 0, 10, S("abcdefghijklmnopqrst"), 0, 21, -10);
     test(S("abcdefghijklmnopqrst"), 0, 10, S("abcdefghijklmnopqrst"), 1, 0, 10);
     test(S("abcdefghijklmnopqrst"), 0, 10, S("abcdefghijklmnopqrst"), 1, 1, -1);
     test(S("abcdefghijklmnopqrst"), 0, 10, S("abcdefghijklmnopqrst"), 1, 9, -1);
TEST_CONSTEXPR_CXX20 bool test39()
     test(S("abcdefghijklmnopqrst"), 0, 19, S("abcdefghijklmnopqrst"), 19, 2, -19);
     test(S("abcdefghijklmnopqrst"), 0, 19, S("abcdefghijklmnopqrst"), 20, 0, 19);
     test(S("abcdefghijklmnopqrst"), 0, 19, S("abcdefghijklmnopqrst"), 20, 1, 19);
     test(S("abcdefghijklmnopqrst"), 0, 19, S("abcdefghijklmnopqrst"), 21, 0, 0);
     test(S("abcdefghijklmnopqrst"), 0, 20, S(""), 0, 0, 20);
     test(S("abcdefghijklmnopqrst"), 0, 20, S(""), 0, 1, 20);
     test(S("abcdefghijklmnopqrst"), 0, 20, S(""), 1, 0, 0);
     test(S("abcdefghijklmnopqrst"), 0, 20, S("abcde"), 0, 0, 20);
+
+    return true;
 }
 
 template <class S>
-void test40()
+TEST_CONSTEXPR_CXX20 bool test40()
 {
     test(S("abcdefghijklmnopqrst"), 0, 20, S("abcde"), 0, 1, 19);
     test(S("abcdefghijklmnopqrst"), 0, 20, S("abcde"), 0, 2, 18);
     test(S("abcdefghijklmnopqrst"), 0, 20, S("abcde"), 0, 4, 16);
     test(S("abcdefghijklmnopqrst"), 0, 20, S("abcde"), 0, 5, 15);
     test(S("abcdefghijklmnopqrst"), 0, 20, S("abcde"), 0, 6, 15);
     test(S("abcdefghijklmnopqrst"), 0, 20, S("abcde"), 1, 0, 20);
     test(S("abcdefghijklmnopqrst"), 0, 20, S("abcde"), 1, 1, -1);
TEST_CONSTEXPR_CXX20 bool test40()
     test(S("abcdefghijklmnopqrst"), 0, 21, S("abcde"), 4, 2, -4);
     test(S("abcdefghijklmnopqrst"), 0, 21, S("abcde"), 5, 0, 20);
     test(S("abcdefghijklmnopqrst"), 0, 21, S("abcde"), 5, 1, 20);
     test(S("abcdefghijklmnopqrst"), 0, 21, S("abcde"), 6, 0, 0);
     test(S("abcdefghijklmnopqrst"), 0, 21, S("abcdefghij"), 0, 0, 20);
     test(S("abcdefghijklmnopqrst"), 0, 21, S("abcdefghij"), 0, 1, 19);
     test(S("abcdefghijklmnopqrst"), 0, 21, S("abcdefghij"), 0, 5, 15);
     test(S("abcdefghijklmnopqrst"), 0, 21, S("abcdefghij"), 0, 9, 11);
+
+    return true;
 }
 
 template <class S>
-void test41()
+TEST_CONSTEXPR_CXX20 bool test41()
 {
     test(S("abcdefghijklmnopqrst"), 0, 21, S("abcdefghij"), 0, 10, 10);
     test(S("abcdefghijklmnopqrst"), 0, 21, S("abcdefghij"), 0, 11, 10);
     test(S("abcdefghijklmnopqrst"), 0, 21, S("abcdefghij"), 1, 0, 20);
     test(S("abcdefghijklmnopqrst"), 0, 21, S("abcdefghij"), 1, 1, -1);
     test(S("abcdefghijklmnopqrst"), 0, 21, S("abcdefghij"), 1, 4, -1);
     test(S("abcdefghijklmnopqrst"), 0, 21, S("abcdefghij"), 1, 8, -1);
     test(S("abcdefghijklmnopqrst"), 0, 21, S("abcdefghij"), 1, 9, -1);
TEST_CONSTEXPR_CXX20 bool test41()
     test(S("abcdefghijklmnopqrst"), 1, 0, S("abcdefghij"), 10, 1, 0);
     test(S("abcdefghijklmnopqrst"), 1, 0, S("abcdefghij"), 11, 0, 0);
     test(S("abcdefghijklmnopqrst"), 1, 0, S("abcdefghijklmnopqrst"), 0, 0, 0);
     test(S("abcdefghijklmnopqrst"), 1, 0, S("abcdefghijklmnopqrst"), 0, 1, -1);
     test(S("abcdefghijklmnopqrst"), 1, 0, S("abcdefghijklmnopqrst"), 0, 10, -10);
     test(S("abcdefghijklmnopqrst"), 1, 0, S("abcdefghijklmnopqrst"), 0, 19, -19);
     test(S("abcdefghijklmnopqrst"), 1, 0, S("abcdefghijklmnopqrst"), 0, 20, -20);
     test(S("abcdefghijklmnopqrst"), 1, 0, S("abcdefghijklmnopqrst"), 0, 21, -20);
+
+    return true;
 }
 
 template <class S>
-void test42()
+TEST_CONSTEXPR_CXX20 bool test42()
 {
     test(S("abcdefghijklmnopqrst"), 1, 0, S("abcdefghijklmnopqrst"), 1, 0, 0);
     test(S("abcdefghijklmnopqrst"), 1, 0, S("abcdefghijklmnopqrst"), 1, 1, -1);
     test(S("abcdefghijklmnopqrst"), 1, 0, S("abcdefghijklmnopqrst"), 1, 9, -9);
     test(S("abcdefghijklmnopqrst"), 1, 0, S("abcdefghijklmnopqrst"), 1, 18, -18);
     test(S("abcdefghijklmnopqrst"), 1, 0, S("abcdefghijklmnopqrst"), 1, 19, -19);
     test(S("abcdefghijklmnopqrst"), 1, 0, S("abcdefghijklmnopqrst"), 1, 20, -19);
     test(S("abcdefghijklmnopqrst"), 1, 0, S("abcdefghijklmnopqrst"), 10, 0, 0);
TEST_CONSTEXPR_CXX20 bool test42()
     test(S("abcdefghijklmnopqrst"), 1, 9, S(""), 0, 0, 9);
     test(S("abcdefghijklmnopqrst"), 1, 9, S(""), 0, 1, 9);
     test(S("abcdefghijklmnopqrst"), 1, 9, S(""), 1, 0, 0);
     test(S("abcdefghijklmnopqrst"), 1, 9, S("abcde"), 0, 0, 9);
     test(S("abcdefghijklmnopqrst"), 1, 9, S("abcde"), 0, 1, 1);
     test(S("abcdefghijklmnopqrst"), 1, 9, S("abcde"), 0, 2, 1);
     test(S("abcdefghijklmnopqrst"), 1, 9, S("abcde"), 0, 4, 1);
     test(S("abcdefghijklmnopqrst"), 1, 9, S("abcde"), 0, 5, 1);
+
+    return true;
 }
 
 template <class S>
-void test43()
+TEST_CONSTEXPR_CXX20 bool test43()
 {
     test(S("abcdefghijklmnopqrst"), 1, 9, S("abcde"), 0, 6, 1);
     test(S("abcdefghijklmnopqrst"), 1, 9, S("abcde"), 1, 0, 9);
     test(S("abcdefghijklmnopqrst"), 1, 9, S("abcde"), 1, 1, 8);
     test(S("abcdefghijklmnopqrst"), 1, 9, S("abcde"), 1, 2, 7);
     test(S("abcdefghijklmnopqrst"), 1, 9, S("abcde"), 1, 3, 6);
     test(S("abcdefghijklmnopqrst"), 1, 9, S("abcde"), 1, 4, 5);
     test(S("abcdefghijklmnopqrst"), 1, 9, S("abcde"), 1, 5, 5);
TEST_CONSTEXPR_CXX20 bool test43()
     test(S("abcdefghijklmnopqrst"), 1, 18, S("abcdefghij"), 0, 0, 18);
     test(S("abcdefghijklmnopqrst"), 1, 18, S("abcdefghij"), 0, 1, 1);
     test(S("abcdefghijklmnopqrst"), 1, 18, S("abcdefghij"), 0, 5, 1);
     test(S("abcdefghijklmnopqrst"), 1, 18, S("abcdefghij"), 0, 9, 1);
     test(S("abcdefghijklmnopqrst"), 1, 18, S("abcdefghij"), 0, 10, 1);
     test(S("abcdefghijklmnopqrst"), 1, 18, S("abcdefghij"), 0, 11, 1);
     test(S("abcdefghijklmnopqrst"), 1, 18, S("abcdefghij"), 1, 0, 18);
     test(S("abcdefghijklmnopqrst"), 1, 18, S("abcdefghij"), 1, 1, 17);
+
+    return true;
 }
 
 template <class S>
-void test44()
+TEST_CONSTEXPR_CXX20 bool test44()
 {
     test(S("abcdefghijklmnopqrst"), 1, 18, S("abcdefghij"), 1, 4, 14);
     test(S("abcdefghijklmnopqrst"), 1, 18, S("abcdefghij"), 1, 8, 10);
     test(S("abcdefghijklmnopqrst"), 1, 18, S("abcdefghij"), 1, 9, 9);
     test(S("abcdefghijklmnopqrst"), 1, 18, S("abcdefghij"), 1, 10, 9);
     test(S("abcdefghijklmnopqrst"), 1, 18, S("abcdefghij"), 5, 0, 18);
     test(S("abcdefghijklmnopqrst"), 1, 18, S("abcdefghij"), 5, 1, -4);
     test(S("abcdefghijklmnopqrst"), 1, 18, S("abcdefghij"), 5, 2, -4);
TEST_CONSTEXPR_CXX20 bool test44()
     test(S("abcdefghijklmnopqrst"), 1, 19, S("abcdefghijklmnopqrst"), 0, 10, 1);
     test(S("abcdefghijklmnopqrst"), 1, 19, S("abcdefghijklmnopqrst"), 0, 19, 1);
     test(S("abcdefghijklmnopqrst"), 1, 19, S("abcdefghijklmnopqrst"), 0, 20, 1);
     test(S("abcdefghijklmnopqrst"), 1, 19, S("abcdefghijklmnopqrst"), 0, 21, 1);
     test(S("abcdefghijklmnopqrst"), 1, 19, S("abcdefghijklmnopqrst"), 1, 0, 19);
     test(S("abcdefghijklmnopqrst"), 1, 19, S("abcdefghijklmnopqrst"), 1, 1, 18);
     test(S("abcdefghijklmnopqrst"), 1, 19, S("abcdefghijklmnopqrst"), 1, 9, 10);
     test(S("abcdefghijklmnopqrst"), 1, 19, S("abcdefghijklmnopqrst"), 1, 18, 1);
+
+    return true;
 }
 
 template <class S>
-void test45()
+TEST_CONSTEXPR_CXX20 bool test45()
 {
     test(S("abcdefghijklmnopqrst"), 1, 19, S("abcdefghijklmnopqrst"), 1, 19, 0);
     test(S("abcdefghijklmnopqrst"), 1, 19, S("abcdefghijklmnopqrst"), 1, 20, 0);
     test(S("abcdefghijklmnopqrst"), 1, 19, S("abcdefghijklmnopqrst"), 10, 0, 19);
     test(S("abcdefghijklmnopqrst"), 1, 19, S("abcdefghijklmnopqrst"), 10, 1, -9);
     test(S("abcdefghijklmnopqrst"), 1, 19, S("abcdefghijklmnopqrst"), 10, 5, -9);
     test(S("abcdefghijklmnopqrst"), 1, 19, S("abcdefghijklmnopqrst"), 10, 9, -9);
     test(S("abcdefghijklmnopqrst"), 1, 19, S("abcdefghijklmnopqrst"), 10, 10, -9);
TEST_CONSTEXPR_CXX20 bool test45()
     test(S("abcdefghijklmnopqrst"), 10, 0, S("abcde"), 0, 1, -1);
     test(S("abcdefghijklmnopqrst"), 10, 0, S("abcde"), 0, 2, -2);
     test(S("abcdefghijklmnopqrst"), 10, 0, S("abcde"), 0, 4, -4);
     test(S("abcdefghijklmnopqrst"), 10, 0, S("abcde"), 0, 5, -5);
     test(S("abcdefghijklmnopqrst"), 10, 0, S("abcde"), 0, 6, -5);
     test(S("abcdefghijklmnopqrst"), 10, 0, S("abcde"), 1, 0, 0);
     test(S("abcdefghijklmnopqrst"), 10, 0, S("abcde"), 1, 1, -1);
     test(S("abcdefghijklmnopqrst"), 10, 0, S("abcde"), 1, 2, -2);
+
+    return true;
 }
 
 template <class S>
-void test46()
+TEST_CONSTEXPR_CXX20 bool test46()
 {
     test(S("abcdefghijklmnopqrst"), 10, 0, S("abcde"), 1, 3, -3);
     test(S("abcdefghijklmnopqrst"), 10, 0, S("abcde"), 1, 4, -4);
     test(S("abcdefghijklmnopqrst"), 10, 0, S("abcde"), 1, 5, -4);
     test(S("abcdefghijklmnopqrst"), 10, 0, S("abcde"), 2, 0, 0);
     test(S("abcdefghijklmnopqrst"), 10, 0, S("abcde"), 2, 1, -1);
     test(S("abcdefghijklmnopqrst"), 10, 0, S("abcde"), 2, 2, -2);
     test(S("abcdefghijklmnopqrst"), 10, 0, S("abcde"), 2, 3, -3);
TEST_CONSTEXPR_CXX20 bool test46()
     test(S("abcdefghijklmnopqrst"), 10, 1, S("abcdefghij"), 0, 10, 10);
     test(S("abcdefghijklmnopqrst"), 10, 1, S("abcdefghij"), 0, 11, 10);
     test(S("abcdefghijklmnopqrst"), 10, 1, S("abcdefghij"), 1, 0, 1);
     test(S("abcdefghijklmnopqrst"), 10, 1, S("abcdefghij"), 1, 1, 9);
     test(S("abcdefghijklmnopqrst"), 10, 1, S("abcdefghij"), 1, 4, 9);
     test(S("abcdefghijklmnopqrst"), 10, 1, S("abcdefghij"), 1, 8, 9);
     test(S("abcdefghijklmnopqrst"), 10, 1, S("abcdefghij"), 1, 9, 9);
     test(S("abcdefghijklmnopqrst"), 10, 1, S("abcdefghij"), 1, 10, 9);
+
+    return true;
 }
 
 template <class S>
-void test47()
+TEST_CONSTEXPR_CXX20 bool test47()
 {
     test(S("abcdefghijklmnopqrst"), 10, 1, S("abcdefghij"), 5, 0, 1);
     test(S("abcdefghijklmnopqrst"), 10, 1, S("abcdefghij"), 5, 1, 5);
     test(S("abcdefghijklmnopqrst"), 10, 1, S("abcdefghij"), 5, 2, 5);
     test(S("abcdefghijklmnopqrst"), 10, 1, S("abcdefghij"), 5, 4, 5);
     test(S("abcdefghijklmnopqrst"), 10, 1, S("abcdefghij"), 5, 5, 5);
     test(S("abcdefghijklmnopqrst"), 10, 1, S("abcdefghij"), 5, 6, 5);
     test(S("abcdefghijklmnopqrst"), 10, 1, S("abcdefghij"), 9, 0, 1);
TEST_CONSTEXPR_CXX20 bool test47()
     test(S("abcdefghijklmnopqrst"), 10, 5, S("abcdefghijklmnopqrst"), 1, 0, 5);
     test(S("abcdefghijklmnopqrst"), 10, 5, S("abcdefghijklmnopqrst"), 1, 1, 9);
     test(S("abcdefghijklmnopqrst"), 10, 5, S("abcdefghijklmnopqrst"), 1, 9, 9);
     test(S("abcdefghijklmnopqrst"), 10, 5, S("abcdefghijklmnopqrst"), 1, 18, 9);
     test(S("abcdefghijklmnopqrst"), 10, 5, S("abcdefghijklmnopqrst"), 1, 19, 9);
     test(S("abcdefghijklmnopqrst"), 10, 5, S("abcdefghijklmnopqrst"), 1, 20, 9);
     test(S("abcdefghijklmnopqrst"), 10, 5, S("abcdefghijklmnopqrst"), 10, 0, 5);
     test(S("abcdefghijklmnopqrst"), 10, 5, S("abcdefghijklmnopqrst"), 10, 1, 4);
+
+    return true;
 }
 
 template <class S>
-void test48()
+TEST_CONSTEXPR_CXX20 bool test48()
 {
     test(S("abcdefghijklmnopqrst"), 10, 5, S("abcdefghijklmnopqrst"), 10, 5, 0);
     test(S("abcdefghijklmnopqrst"), 10, 5, S("abcdefghijklmnopqrst"), 10, 9, -4);
     test(S("abcdefghijklmnopqrst"), 10, 5, S("abcdefghijklmnopqrst"), 10, 10, -5);
     test(S("abcdefghijklmnopqrst"), 10, 5, S("abcdefghijklmnopqrst"), 10, 11, -5);
     test(S("abcdefghijklmnopqrst"), 10, 5, S("abcdefghijklmnopqrst"), 19, 0, 5);
     test(S("abcdefghijklmnopqrst"), 10, 5, S("abcdefghijklmnopqrst"), 19, 1, -9);
     test(S("abcdefghijklmnopqrst"), 10, 5, S("abcdefghijklmnopqrst"), 19, 2, -9);
TEST_CONSTEXPR_CXX20 bool test48()
     test(S("abcdefghijklmnopqrst"), 10, 10, S("abcde"), 0, 6, 10);
     test(S("abcdefghijklmnopqrst"), 10, 10, S("abcde"), 1, 0, 10);
     test(S("abcdefghijklmnopqrst"), 10, 10, S("abcde"), 1, 1, 9);
     test(S("abcdefghijklmnopqrst"), 10, 10, S("abcde"), 1, 2, 9);
     test(S("abcdefghijklmnopqrst"), 10, 10, S("abcde"), 1, 3, 9);
     test(S("abcdefghijklmnopqrst"), 10, 10, S("abcde"), 1, 4, 9);
     test(S("abcdefghijklmnopqrst"), 10, 10, S("abcde"), 1, 5, 9);
     test(S("abcdefghijklmnopqrst"), 10, 10, S("abcde"), 2, 0, 10);
+
+    return true;
 }
 
 template <class S>
-void test49()
+TEST_CONSTEXPR_CXX20 bool test49()
 {
     test(S("abcdefghijklmnopqrst"), 10, 10, S("abcde"), 2, 1, 8);
     test(S("abcdefghijklmnopqrst"), 10, 10, S("abcde"), 2, 2, 8);
     test(S("abcdefghijklmnopqrst"), 10, 10, S("abcde"), 2, 3, 8);
     test(S("abcdefghijklmnopqrst"), 10, 10, S("abcde"), 2, 4, 8);
     test(S("abcdefghijklmnopqrst"), 10, 10, S("abcde"), 4, 0, 10);
     test(S("abcdefghijklmnopqrst"), 10, 10, S("abcde"), 4, 1, 6);
     test(S("abcdefghijklmnopqrst"), 10, 10, S("abcde"), 4, 2, 6);
TEST_CONSTEXPR_CXX20 bool test49()
     test(S("abcdefghijklmnopqrst"), 10, 11, S("abcdefghij"), 1, 4, 9);
     test(S("abcdefghijklmnopqrst"), 10, 11, S("abcdefghij"), 1, 8, 9);
     test(S("abcdefghijklmnopqrst"), 10, 11, S("abcdefghij"), 1, 9, 9);
     test(S("abcdefghijklmnopqrst"), 10, 11, S("abcdefghij"), 1, 10, 9);
     test(S("abcdefghijklmnopqrst"), 10, 11, S("abcdefghij"), 5, 0, 10);
     test(S("abcdefghijklmnopqrst"), 10, 11, S("abcdefghij"), 5, 1, 5);
     test(S("abcdefghijklmnopqrst"), 10, 11, S("abcdefghij"), 5, 2, 5);
     test(S("abcdefghijklmnopqrst"), 10, 11, S("abcdefghij"), 5, 4, 5);
+
+    return true;
 }
 
 template <class S>
-void test50()
+TEST_CONSTEXPR_CXX20 bool test50()
 {
     test(S("abcdefghijklmnopqrst"), 10, 11, S("abcdefghij"), 5, 5, 5);
     test(S("abcdefghijklmnopqrst"), 10, 11, S("abcdefghij"), 5, 6, 5);
     test(S("abcdefghijklmnopqrst"), 10, 11, S("abcdefghij"), 9, 0, 10);
     test(S("abcdefghijklmnopqrst"), 10, 11, S("abcdefghij"), 9, 1, 1);
     test(S("abcdefghijklmnopqrst"), 10, 11, S("abcdefghij"), 9, 2, 1);
     test(S("abcdefghijklmnopqrst"), 10, 11, S("abcdefghij"), 10, 0, 10);
     test(S("abcdefghijklmnopqrst"), 10, 11, S("abcdefghij"), 10, 1, 10);
TEST_CONSTEXPR_CXX20 bool test50()
     test(S("abcdefghijklmnopqrst"), 19, 0, S("abcdefghijklmnopqrst"), 1, 19, -19);
     test(S("abcdefghijklmnopqrst"), 19, 0, S("abcdefghijklmnopqrst"), 1, 20, -19);
     test(S("abcdefghijklmnopqrst"), 19, 0, S("abcdefghijklmnopqrst"), 10, 0, 0);
     test(S("abcdefghijklmnopqrst"), 19, 0, S("abcdefghijklmnopqrst"), 10, 1, -1);
     test(S("abcdefghijklmnopqrst"), 19, 0, S("abcdefghijklmnopqrst"), 10, 5, -5);
     test(S("abcdefghijklmnopqrst"), 19, 0, S("abcdefghijklmnopqrst"), 10, 9, -9);
     test(S("abcdefghijklmnopqrst"), 19, 0, S("abcdefghijklmnopqrst"), 10, 10, -10);
     test(S("abcdefghijklmnopqrst"), 19, 0, S("abcdefghijklmnopqrst"), 10, 11, -10);
+
+    return true;
 }
 
 template <class S>
-void test51()
+TEST_CONSTEXPR_CXX20 bool test51()
 {
     test(S("abcdefghijklmnopqrst"), 19, 0, S("abcdefghijklmnopqrst"), 19, 0, 0);
     test(S("abcdefghijklmnopqrst"), 19, 0, S("abcdefghijklmnopqrst"), 19, 1, -1);
     test(S("abcdefghijklmnopqrst"), 19, 0, S("abcdefghijklmnopqrst"), 19, 2, -1);
     test(S("abcdefghijklmnopqrst"), 19, 0, S("abcdefghijklmnopqrst"), 20, 0, 0);
     test(S("abcdefghijklmnopqrst"), 19, 0, S("abcdefghijklmnopqrst"), 20, 1, 0);
     test(S("abcdefghijklmnopqrst"), 19, 0, S("abcdefghijklmnopqrst"), 21, 0, 0);
     test(S("abcdefghijklmnopqrst"), 19, 1, S(""), 0, 0, 1);
TEST_CONSTEXPR_CXX20 bool test51()
     test(S("abcdefghijklmnopqrst"), 19, 2, S("abcde"), 1, 3, 18);
     test(S("abcdefghijklmnopqrst"), 19, 2, S("abcde"), 1, 4, 18);
     test(S("abcdefghijklmnopqrst"), 19, 2, S("abcde"), 1, 5, 18);
     test(S("abcdefghijklmnopqrst"), 19, 2, S("abcde"), 2, 0, 1);
     test(S("abcdefghijklmnopqrst"), 19, 2, S("abcde"), 2, 1, 17);
     test(S("abcdefghijklmnopqrst"), 19, 2, S("abcde"), 2, 2, 17);
     test(S("abcdefghijklmnopqrst"), 19, 2, S("abcde"), 2, 3, 17);
     test(S("abcdefghijklmnopqrst"), 19, 2, S("abcde"), 2, 4, 17);
+
+    return true;
 }
 
 template <class S>
-void test52()
+TEST_CONSTEXPR_CXX20 bool test52()
 {
     test(S("abcdefghijklmnopqrst"), 19, 2, S("abcde"), 4, 0, 1);
     test(S("abcdefghijklmnopqrst"), 19, 2, S("abcde"), 4, 1, 15);
     test(S("abcdefghijklmnopqrst"), 19, 2, S("abcde"), 4, 2, 15);
     test(S("abcdefghijklmnopqrst"), 19, 2, S("abcde"), 5, 0, 1);
     test(S("abcdefghijklmnopqrst"), 19, 2, S("abcde"), 5, 1, 1);
     test(S("abcdefghijklmnopqrst"), 19, 2, S("abcde"), 6, 0, 0);
     test(S("abcdefghijklmnopqrst"), 19, 2, S("abcdefghij"), 0, 0, 1);
TEST_CONSTEXPR_CXX20 bool test52()
     test(S("abcdefghijklmnopqrst"), 20, 0, S("abcdefghij"), 5, 0, 0);
     test(S("abcdefghijklmnopqrst"), 20, 0, S("abcdefghij"), 5, 1, -1);
     test(S("abcdefghijklmnopqrst"), 20, 0, S("abcdefghij"), 5, 2, -2);
     test(S("abcdefghijklmnopqrst"), 20, 0, S("abcdefghij"), 5, 4, -4);
     test(S("abcdefghijklmnopqrst"), 20, 0, S("abcdefghij"), 5, 5, -5);
     test(S("abcdefghijklmnopqrst"), 20, 0, S("abcdefghij"), 5, 6, -5);
     test(S("abcdefghijklmnopqrst"), 20, 0, S("abcdefghij"), 9, 0, 0);
     test(S("abcdefghijklmnopqrst"), 20, 0, S("abcdefghij"), 9, 1, -1);
+
+    return true;
 }
 
 template <class S>
-void test53()
+TEST_CONSTEXPR_CXX20 bool test53()
 {
     test(S("abcdefghijklmnopqrst"), 20, 0, S("abcdefghij"), 9, 2, -1);
     test(S("abcdefghijklmnopqrst"), 20, 0, S("abcdefghij"), 10, 0, 0);
     test(S("abcdefghijklmnopqrst"), 20, 0, S("abcdefghij"), 10, 1, 0);
     test(S("abcdefghijklmnopqrst"), 20, 0, S("abcdefghij"), 11, 0, 0);
     test(S("abcdefghijklmnopqrst"), 20, 0, S("abcdefghijklmnopqrst"), 0, 0, 0);
     test(S("abcdefghijklmnopqrst"), 20, 0, S("abcdefghijklmnopqrst"), 0, 1, -1);
     test(S("abcdefghijklmnopqrst"), 20, 0, S("abcdefghijklmnopqrst"), 0, 10, -10);
TEST_CONSTEXPR_CXX20 bool test53()
     test(S("abcdefghijklmnopqrst"), 20, 1, S("abcdefghijklmnopqrst"), 10, 5, -5);
     test(S("abcdefghijklmnopqrst"), 20, 1, S("abcdefghijklmnopqrst"), 10, 9, -9);
     test(S("abcdefghijklmnopqrst"), 20, 1, S("abcdefghijklmnopqrst"), 10, 10, -10);
     test(S("abcdefghijklmnopqrst"), 20, 1, S("abcdefghijklmnopqrst"), 10, 11, -10);
     test(S("abcdefghijklmnopqrst"), 20, 1, S("abcdefghijklmnopqrst"), 19, 0, 0);
     test(S("abcdefghijklmnopqrst"), 20, 1, S("abcdefghijklmnopqrst"), 19, 1, -1);
     test(S("abcdefghijklmnopqrst"), 20, 1, S("abcdefghijklmnopqrst"), 19, 2, -1);
     test(S("abcdefghijklmnopqrst"), 20, 1, S("abcdefghijklmnopqrst"), 20, 0, 0);
+
+    return true;
 }
 
 template <class S>
-void test54()
+TEST_CONSTEXPR_CXX20 bool test54()
 {
     test(S("abcdefghijklmnopqrst"), 20, 1, S("abcdefghijklmnopqrst"), 20, 1, 0);
     test(S("abcdefghijklmnopqrst"), 20, 1, S("abcdefghijklmnopqrst"), 21, 0, 0);
     test(S("abcdefghijklmnopqrst"), 21, 0, S(""), 0, 0, 0);
     test(S("abcdefghijklmnopqrst"), 21, 0, S(""), 0, 1, 0);
     test(S("abcdefghijklmnopqrst"), 21, 0, S(""), 1, 0, 0);
     test(S("abcdefghijklmnopqrst"), 21, 0, S("abcde"), 0, 0, 0);
     test(S("abcdefghijklmnopqrst"), 21, 0, S("abcde"), 0, 1, 0);
TEST_CONSTEXPR_CXX20 bool test54()
     test(S("abcdefghijklmnopqrst"), 21, 0, S("abcdefghijklmnopqrst"), 10, 10, 0);
     test(S("abcdefghijklmnopqrst"), 21, 0, S("abcdefghijklmnopqrst"), 10, 11, 0);
     test(S("abcdefghijklmnopqrst"), 21, 0, S("abcdefghijklmnopqrst"), 19, 0, 0);
     test(S("abcdefghijklmnopqrst"), 21, 0, S("abcdefghijklmnopqrst"), 19, 1, 0);
     test(S("abcdefghijklmnopqrst"), 21, 0, S("abcdefghijklmnopqrst"), 19, 2, 0);
     test(S("abcdefghijklmnopqrst"), 21, 0, S("abcdefghijklmnopqrst"), 20, 0, 0);
     test(S("abcdefghijklmnopqrst"), 21, 0, S("abcdefghijklmnopqrst"), 20, 1, 0);
     test(S("abcdefghijklmnopqrst"), 21, 0, S("abcdefghijklmnopqrst"), 21, 0, 0);
+
+    return true;
 }
 
 template<class S>
-void test55()
+TEST_CONSTEXPR_CXX20 bool test55()
 {
     test_npos(S(""), 0, 0, S(""), 0, 0);
     test_npos(S(""), 0, 0, S("abcde"), 0, -5);
     test_npos(S("abcde"), 0, 0, S("abcdefghij"), 0, -10);
     test_npos(S("abcde"), 0, 0, S("abcdefghij"), 1, -9);
     test_npos(S("abcde"), 0, 0, S("abcdefghij"), 5, -5);
+
+    return true;
 }
 
-int main(int, char**)
-{
-    {
-    typedef std::string S;
+template<class S>
+TEST_CONSTEXPR_CXX20 void tests() {
     test0<S>();
     test1<S>();
     test2<S>();
     test3<S>();
     test4<S>();
     test5<S>();
     test6<S>();
     test7<S>();
TEST_CONSTEXPR_CXX20 void tests() {
     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>();
-    test30<S>();
-    test31<S>();
-    test32<S>();
-    test33<S>();
-    test34<S>();
-    test35<S>();
-    test36<S>();
-    test37<S>();
-    test38<S>();
-    test39<S>();
-    test40<S>();
     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>();
     test30<S>();
     test31<S>();
     test32<S>();
     test33<S>();
     test34<S>();
TEST_CONSTEXPR_CXX20 void tests() {
     test48<S>();
     test49<S>();
     test50<S>();
     test51<S>();
     test52<S>();
     test53<S>();
     test54<S>();
     test55<S>();
-    }
+
+#if TEST_STD_VER > 17
+    static_assert(test0<S>());
+    static_assert(test1<S>());
+    static_assert(test2<S>());
+    static_assert(test3<S>());
+    static_assert(test4<S>());
+    static_assert(test5<S>());
+    static_assert(test6<S>());
+    static_assert(test7<S>());
+    static_assert(test8<S>());
+    static_assert(test9<S>());
+    static_assert(test10<S>());
+    static_assert(test11<S>());
+    static_assert(test12<S>());
+    static_assert(test13<S>());
+    static_assert(test14<S>());
+    static_assert(test15<S>());
+    static_assert(test16<S>());
+    static_assert(test17<S>());
+    static_assert(test18<S>());
+    static_assert(test19<S>());
+    static_assert(test20<S>());
+    static_assert(test21<S>());
+    static_assert(test22<S>());
+    static_assert(test23<S>());
+    static_assert(test24<S>());
+    static_assert(test41<S>());
+    static_assert(test42<S>());
+    static_assert(test27<S>());
+    static_assert(test28<S>());
+    static_assert(test29<S>());
+    static_assert(test30<S>());
+    static_assert(test31<S>());
+    static_assert(test32<S>());
+    static_assert(test33<S>());
+    static_assert(test34<S>());
+    static_assert(test35<S>());
+    static_assert(test36<S>());
+    static_assert(test37<S>());
+    static_assert(test38<S>());
+    static_assert(test39<S>());
+    static_assert(test40<S>());
+    static_assert(test41<S>());
+    static_assert(test42<S>());
+    static_assert(test43<S>());
+    static_assert(test44<S>());
+    static_assert(test45<S>());
+    static_assert(test46<S>());
+    static_assert(test47<S>());
+    static_assert(test48<S>());
+    static_assert(test49<S>());
+    static_assert(test50<S>());
+    static_assert(test51<S>());
+    static_assert(test52<S>());
+    static_assert(test53<S>());
+    static_assert(test54<S>());
+    static_assert(test55<S>());
+#endif
+
+
+int main(int, char**) {
+  tests<std::string>();
+#if TEST_STD_VER >= 11
+  tests<std::basic_string<char, std::char_traits<char>, min_allocator<char>>>();
 #endif
 
   return 0;
 }

libcxx/test/std/strings/basic.string/string.ops/string_find.last.not.of/string_view_size.pass.cpp

 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 #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));
     assert(s.find_last_not_of(sv, pos) == x);
     if (x != S::npos)
         assert(x <= pos && x < s.size());
 }
 
 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));
     assert(s.find_last_not_of(sv) == x);
     if (x != S::npos)
         assert(x < s.size());
 }
 
 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);
     test(S(""), SV("pqlnkmbdjo"), 0, S::npos);
     test(S(""), SV("qkamfogpnljdcshbreti"), 0, S::npos);
     test(S(""), SV(""), 1, S::npos);
     test(S(""), SV("bjaht"), 1, S::npos);
     test(S(""), SV("hjlcmgpket"), 1, S::npos);
TEST_CONSTEXPR_CXX20 void test0()
     test(S("rphmlekgfscndtaobiqj"), SV("lsckfnqgdahejiopbtmr"), 20, S::npos);
     test(S("liatsqdoegkmfcnbhrpj"), SV(""), 21, 19);
     test(S("binjagtfldkrspcomqeh"), SV("gfsrt"), 21, 19);
     test(S("latkmisecnorjbfhqpdg"), SV("pfsocbhjtm"), 21, 19);
     test(S("lecfratdjkhnsmqpoigb"), SV("tpflmdnoicjgkberhqsa"), 21, S::npos);
 }
 
 template <class S, class SV>
-void test1()
+TEST_CONSTEXPR_CXX20 void test1()
 {
     test(S(""), SV(""), S::npos);
     test(S(""), SV("laenf"), S::npos);
     test(S(""), SV("pqlnkmbdjo"), S::npos);
     test(S(""), SV("qkamfogpnljdcshbreti"), S::npos);
     test(S("nhmko"), SV(""), 4);
     test(S("lahfb"), SV("irkhs"), 4);
     test(S("gmfhd"), SV("kantesmpgj"), 4);
     test(S("odaft"), SV("oknlrstdpiqmjbaghcfe"), S::npos);
     test(S("eolhfgpjqk"), SV(""), 9);
     test(S("nbatdlmekr"), SV("bnrpe"), 8);
     test(S("jdmciepkaq"), SV("jtdaefblso"), 9);
     test(S("hkbgspoflt"), SV("oselktgbcapndfjihrmq"), S::npos);
     test(S("gprdcokbnjhlsfmtieqa"), SV(""), 19);
     test(S("qjghlnftcaismkropdeb"), SV("bjaht"), 18);
     test(S("pnalfrdtkqcmojiesbhg"), SV("hjlcmgpket"), 17);
     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;
     test0<S, SV>();
     test1<S, SV>();
     }
 #if TEST_STD_VER >= 11
     {
 //     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
 //     typedef std::string_view SV;
 //     test0<S, SV>();
 //     test1<S, SV>();
     }
 #endif
     
+  return true;
+}
+
+int main(int, char**) {
+  test();
+#if TEST_STD_VER > 17
+  static_assert(test());
+#endif
+
   return 0;
 }

libcxx/test/std/strings/basic.string/string.starts_with/starts_with.char.pass.cpp

 // <string>
 
 //   bool starts_with(charT x) const noexcept;
 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 
-int main(int, char**)
-{
-    {
+TEST_CONSTEXPR_CXX20 bool test() {
     typedef std::string S;
     S  s1 {};
     S  s2 { "abcde", 5 };
 
     ASSERT_NOEXCEPT(s1.starts_with('e'));
 
     assert (!s1.starts_with('a'));
     assert (!s1.starts_with('x'));
     assert ( s2.starts_with('a'));
     assert (!s2.starts_with('x'));
     }
     
+  return true;
+}
+
+int main(int, char**) {
+  test();
+#if TEST_STD_VER > 17
+  static_assert(test());
+#endif
+
   return 0;
 }

libcxx/test/support/test_macros.h

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef 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>.
 #ifdef __has_include
 # if __has_include("<__config>")
 #   include <__config>
 #   define TEST_IMP_INCLUDED_HEADER
 # endif