[libc++] Prepare string tests for constexpr

[philnik]

Summary

These are the last™ changes to the tests for constexpr preparation.

[philnik]

• Fix CI

[• Quuxplusone]

LGTM%comments, and all the comments are pretty easy to deal with, I think.

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

24

Prefer TEST_CONSTEXPR (unless I'm missing a reason this doesn't work in C++11).

27

This either calls std::malloc or throws. I don't think it's safely constexpr-qualifiable even in C++20. Does it need to be?
Ditto deallocate.

41–67

Pre-existing: It'd be awesome to s/poca/pocca/ and move the operators into hidden friends. But in a separate PR for sure.

You put the poca_alloc codepath on lines 109-127 under !TEST_IS_CONSTANT_EVALUATED; is it possible that these constexpr-qualifications are unnecessary?

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

233–235

This is missing an >= 11 guard; but in fact I think what you should do here is remove this guard, and move the guards around test[_lwg]2583 inside the function body. Also some drive-by cleanup:

void test_lwg2583()
{
#if TEST_STD_VER >= 11 && defined(TEST_HAS_NO_EXCEPTIONS)
    typedef std::basic_string<char, std::char_traits<char>, test_allocator<char>> StringA;
    std::vector<StringA, std::scoped_allocator_adaptor<test_allocator<StringA>>> vs;
    StringA s{"1234"};
    vs.emplace_back(s, 2);
    try {
        vs.emplace_back(s, 5);
        assert(false);
    } catch (const std::out_of_range&) { }
#endif
}

libcxx/test/std/strings/basic.string/string.modifiers/string_append/iterator.pass.cpp

218–233

Here, I assume the only problem is with first's reinterpret_cast; the other 3 calls to test are OK, right? Consider refactoring to pull out first into its own code block (at the expense of some duplication, I assume, but that's fine).

[philnik]

• Address comments

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

41–67

Yep, it only has to be a constexpr type, so making the constructors constexpr is enough.

[EricWF]

Doesn't this change make all of the tests with functions decorated with TEST_CONSTEXPR_AFTER_CXX20 undefined behavior, since it's undefined to have constexpr on a function that is never constexpr?

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

93

Please don't go adding commented out tests in the future.

libcxx/test/std/strings/basic.string/string.modifiers/string_assign/iterator.pass.cpp

34

Is this ever constexpr?

[philnik]

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

93

This was requested by Louis.

[philnik]

• Address comments

@EricWF How could this be undefined bahavior? All the tests are templated on the string, so it's possible to give them a constexpr string.

[• Quuxplusone]

In D120951#3373293, @philnik wrote:

Doesn't this change make all of the tests with functions decorated with TEST_CONSTEXPR_AFTER_CXX20 undefined behavior, since it's undefined to have constexpr on a function that is never constexpr?

@EricWF How could this be undefined bahavior? All the tests are templated on the string, so it's possible to give them a constexpr string.

This is theory versus practice. In theory, it's IFNDR to define a template that can never be validly instantiated. But in practice the meaning of "can never" is really unclear: does it mean "is never"? how much imagination does the compiler have to possess here? So in practice, compilers don't check template definitions prior to instantiation, and thus templates are always safe to mark constexpr. We're using that practical license here. I don't believe there's any practical problem with what we're doing here, IFNDR-wise. (And within a couple of months even the theoretical question should be moot anyway, right? hopefully?)

[philnik]

ping

[Mordante]

LGTM! Just curious did you test locally whether these are really the final preparation changes required?
Note I don't see that as blocking, the additional changes can be done when std::string is made constexpr.

[philnik]

In D120951#3394287, @Mordante wrote:

LGTM! Just curious did you test locally whether these are really the final preparation changes required?
Note I don't see that as blocking, the additional changes can be done when std::string is made constexpr.

I have a (almost) working constexpr std::string version locally and these should be the last diffs in the test files other than actually enabling the tests. I had to cherry-pick these changes manually, so I might have missed something.

libcxx/test/std/strings/basic.string/string.capacity/reserve_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(typename S::size_type min_cap, typename S::size_type erased_index, typename S::size_type res_arg)
 {
     S s(min_cap, 'a');
     s.erase(erased_index);
     assert(s.size() == erased_index);
     assert(s.capacity() >= min_cap); // Check that we really have at least this capacity.
 
 #if TEST_STD_VER > 17
     typename S::size_type old_cap = s.capacity();
 #endif
     S s0 = s;
     if (res_arg <= s.max_size())
     {
         s.reserve(res_arg);
         LIBCPP_ASSERT(s.__invariants());
         assert(s == s0);
         assert(s.capacity() >= res_arg);
         assert(s.capacity() >= s.size());
 #if TEST_STD_VER > 17
         assert(s.capacity() >= old_cap); // reserve never shrinks as of P0966 (C++20)
 #endif
     }
 #ifndef TEST_HAS_NO_EXCEPTIONS
-    else
+    else if (!TEST_IS_CONSTANT_EVALUATED)
     {
         try
         {
             s.reserve(res_arg);
             LIBCPP_ASSERT(s.__invariants());
             assert(false);
         }
         catch (std::length_error&)

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

 {
     if (n <= s.max_size())
     {
         s.resize(n);
         LIBCPP_ASSERT(s.__invariants());
         assert(s == expected);
     }
 #ifndef TEST_HAS_NO_EXCEPTIONS
-    else
+    else if (!TEST_IS_CONSTANT_EVALUATED)
     {
         try
         {
             s.resize(n);
             assert(false);
         }
         catch (std::length_error&)
         {

libcxx/test/std/strings/basic.string/string.capacity/resize_size_char.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 n, typename S::value_type c, S expected)
 {
     if (n <= s.max_size())
     {
         s.resize(n, c);
         LIBCPP_ASSERT(s.__invariants());
         assert(s == expected);
     }
 #ifndef TEST_HAS_NO_EXCEPTIONS
-    else
+    else if (!TEST_IS_CONSTANT_EVALUATED)
     {
         try
         {
             s.resize(n, c);
             assert(false);
         }
         catch (std::length_error&)
         {

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

 
 #include <string>
 #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 old_cap = s.capacity();
     S s0 = s;
     s.shrink_to_fit();
     LIBCPP_ASSERT(s.__invariants());
     assert(s == s0);
     assert(s.capacity() <= old_cap);
     assert(s.capacity() >= s.size());
 }
 
 bool test() {
-    {
     typedef std::string S;
     S s;
     test(s);
 
     s.assign(10, 'a');
     s.erase(5);
     test(s);
 
     s.assign(100, 'a');
     s.erase(50);
     test(s);
-    }
 #if TEST_STD_VER >= 11
-    {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     S s;
     test(s);
 
     s.assign(10, 'a');
     s.erase(5);
     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/T_size_size.pass.cpp

if (pos <= sv.size())
         assert(pos <= sv.size());
         std::size_t rlen = std::min(sv.size() - pos, n);
         assert(s2.size() == rlen);
         assert(T::compare(s2.data(), sv.data() + pos, rlen) == 0);
         assert(s2.get_allocator() == A());
         assert(s2.capacity() >= s2.size());
     }
 #ifndef TEST_HAS_NO_EXCEPTIONS
-    else
+    else if (!TEST_IS_CONSTANT_EVALUATED)
     {
         try
         {
             S s2(sv, static_cast<Size>(pos), static_cast<Size>(n));
             assert(false);
         }
         catch (std::out_of_range&)
         {
if (pos <= sv.size())
         assert(pos <= sv.size());
         std::size_t rlen = std::min(sv.size() - pos, n);
         assert(s2.size() == rlen);
         assert(T::compare(s2.data(), sv.data() + pos, rlen) == 0);
         assert(s2.get_allocator() == a);
         assert(s2.capacity() >= s2.size());
     }
 #ifndef TEST_HAS_NO_EXCEPTIONS
-    else
+    else if (!TEST_IS_CONSTANT_EVALUATED)
     {
         try
         {
             S s2(sv, static_cast<Size>(pos), static_cast<Size>(n), a);
             assert(false);
         }
         catch (std::out_of_range&)
         {

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

 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S>
-void
+TEST_CONSTEXPR_CXX20 void
 test(S s1, typename S::value_type s2)
 {
     typedef typename S::traits_type T;
     s1 = s2;
     LIBCPP_ASSERT(s1.__invariants());
     assert(s1.size() == 1);
     assert(T::eq(s1[0], s2));
     assert(s1.capacity() >= s1.size());

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

 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 #include "test_allocator.h"
 #include "min_allocator.h"
 
 template <class S>
-void
+TEST_CONSTEXPR_CXX20 void
 test(S s1)
 {
     S s2 = s1;
     LIBCPP_ASSERT(s2.__invariants());
     assert(s2 == s1);
     assert(s2.capacity() >= s2.size());
     assert(s2.get_allocator() == s1.get_allocator());
 }

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

 #include "test_macros.h"
 #include "test_allocator.h"
 #include "min_allocator.h"
 
 #ifndef TEST_HAS_NO_EXCEPTIONS
 struct alloc_imp {
     bool active;
 
-    alloc_imp() : active(true) {}
+    TEST_CONSTEXPR_CXX14 alloc_imp() : active(true) {}
 
     template <class T>
-    T* allocate(std::size_t n)
+    TEST_CONSTEXPR_CXX20 T* allocate(std::size_t n)
     {
         if (active)
             return static_cast<T*>(std::malloc(n * sizeof(T)));
         else
             throw std::bad_alloc();
     }
 
     template <class T>
-    void deallocate(T* p, std::size_t) { std::free(p); }
-    void activate  ()                  { active = true; }
-    void deactivate()                  { active = false; }
+    TEST_CONSTEXPR_CXX20 void deallocate(T* p, std::size_t) { std::free(p); }
+    TEST_CONSTEXPR_CXX14 void activate  ()                  { active = true; }
+    TEST_CONSTEXPR_CXX14 void deactivate()                  { active = false; }
 };
 
 template <class T>
 struct poca_alloc {
     typedef T value_type;
     typedef std::true_type propagate_on_container_copy_assignment;
 
     alloc_imp *imp;
 
-    poca_alloc(alloc_imp *imp_) : imp (imp_) {}
+    TEST_CONSTEXPR poca_alloc(alloc_imp *imp_) : imp (imp_) {}
 
     template <class U>
-    poca_alloc(const poca_alloc<U>& other) : imp(other.imp) {}
+    TEST_CONSTEXPR poca_alloc(const poca_alloc<U>& other) : imp(other.imp) {}
 
-    T*   allocate  (std::size_t n)       { return imp->allocate<T>(n);}
-    void deallocate(T* p, std::size_t n) { imp->deallocate(p, n); }
+    TEST_CONSTEXPR_CXX20 T*   allocate  (std::size_t n)       { return imp->allocate<T>(n);}
+    TEST_CONSTEXPR_CXX20 void deallocate(T* p, std::size_t n) { imp->deallocate(p, n); }
 };
 
 template <typename T, typename U>
 bool operator==(const poca_alloc<T>& lhs, const poca_alloc<U>& rhs)
 {
     return lhs.imp == rhs.imp;
 }
 
 template <typename T, typename U>
 bool operator!=(const poca_alloc<T>& lhs, const poca_alloc<U>& rhs)
 {
     return lhs.imp != rhs.imp;
 }
 
 template <class S>
-void test_assign(S &s1, const S& s2)
+TEST_CONSTEXPR_CXX20 void test_assign(S &s1, const S& s2)
 {
     try { s1 = s2; }
     catch ( std::bad_alloc &) { return; }
     assert(false);
 }
 #endif
 
 
 
 template <class S>
-void
+TEST_CONSTEXPR_CXX20 void
 test(S s1, const typename S::allocator_type& a)
 {
     S s2(s1, a);
     LIBCPP_ASSERT(s2.__invariants());
     assert(s2 == s1);
     assert(s2.capacity() >= s2.size());
     assert(s2.get_allocator() == a);
 }
#if TEST_STD_VER >= 11
     typedef min_allocator<char> A;
     typedef std::basic_string<char, std::char_traits<char>, A> S;
     test(S(), A());
     test(S("1"), A());
     test(S("1234567890123456789012345678901234567890123456789012345678901234567890"), A());
   }
 
 #ifndef TEST_HAS_NO_EXCEPTIONS
-  {
+  if (!TEST_IS_CONSTANT_EVALUATED) {
     typedef poca_alloc<char> A;
     typedef std::basic_string<char, std::char_traits<char>, A> S;
     const char * p1 = "This is my first string";
     const char * p2 = "This is my second string";
 
     alloc_imp imp1;
     alloc_imp imp2;
     S s1(p1, A(&imp1));

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

test(unsigned n, charT c, const A& a)
     assert(s2.size() == n);
     for (unsigned i = 0; i < n; ++i)
         assert(s2[i] == c);
     assert(s2.get_allocator() == a);
     assert(s2.capacity() >= s2.size());
 }
 
 template <class Tp>
-void
+TEST_CONSTEXPR_CXX20 void
 test(Tp n, Tp c)
 {
     typedef char charT;
     typedef std::basic_string<charT, std::char_traits<charT>, test_allocator<charT> > S;
     typedef typename S::allocator_type A;
     S s2(n, c);
     LIBCPP_ASSERT(s2.__invariants());
     assert(s2.size() == static_cast<std::size_t>(n));

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

 #include <algorithm>
 #include <cassert>
 
 #include "test_macros.h"
 #include "test_allocator.h"
 #include "min_allocator.h"
 
 template <class charT>
-void
+TEST_CONSTEXPR_CXX20 void
 test(std::basic_string_view<charT> sv)
 {
     typedef std::basic_string<charT, std::char_traits<charT>, test_allocator<charT> > S;
     typedef typename S::traits_type T;
     typedef typename S::allocator_type A;
   {
     S s2(sv);
     LIBCPP_ASSERT(s2.__invariants());
test(std::basic_string_view<charT> sv)
     assert(s2.size() == sv.size());
     assert(T::compare(s2.data(), sv.data(), sv.size()) == 0);
     assert(s2.get_allocator() == A());
     assert(s2.capacity() >= s2.size());
   }
 }
 
 template <class charT, class A>
-void
+TEST_CONSTEXPR_CXX20 void
 test(std::basic_string_view<charT> sv, const A& a)
 {
     typedef std::basic_string<charT, std::char_traits<charT>, A> S;
     typedef typename S::traits_type T;
   {
     S s2(sv, a);
     LIBCPP_ASSERT(s2.__invariants());
     assert(s2.size() == sv.size());

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

if (pos <= str.size())
         LIBCPP_ASSERT(s2.__invariants());
         typename S::size_type rlen = str.size() - pos;
         assert(s2.size() == rlen);
         assert(T::compare(s2.data(), str.data() + pos, rlen) == 0);
         assert(s2.get_allocator() == A());
         assert(s2.capacity() >= s2.size());
     }
 #ifndef TEST_HAS_NO_EXCEPTIONS
-    else
+    else if (!TEST_IS_CONSTANT_EVALUATED)
     {
         try
         {
             S s2(str, pos);
             assert(false);
         }
         catch (std::out_of_range&)
         {
if (pos <= str.size())
         LIBCPP_ASSERT(s2.__invariants());
         typename S::size_type rlen = std::min<typename S::size_type>(str.size() - pos, n);
         assert(s2.size() == rlen);
         assert(T::compare(s2.data(), str.data() + pos, rlen) == 0);
         assert(s2.get_allocator() == A());
         assert(s2.capacity() >= s2.size());
     }
 #ifndef TEST_HAS_NO_EXCEPTIONS
-    else
+    else if (!TEST_IS_CONSTANT_EVALUATED)
     {
         try
         {
             S s2(str, pos, n);
             assert(false);
         }
         catch (std::out_of_range&)
         {
if (pos <= str.size())
         LIBCPP_ASSERT(s2.__invariants());
         typename S::size_type rlen = std::min<typename S::size_type>(str.size() - pos, n);
         assert(s2.size() == rlen);
         assert(T::compare(s2.data(), str.data() + pos, rlen) == 0);
         assert(s2.get_allocator() == a);
         assert(s2.capacity() >= s2.size());
     }
 #ifndef TEST_HAS_NO_EXCEPTIONS
-    else
+    else if (!TEST_IS_CONSTANT_EVALUATED)
     {
         try
         {
             S s2(str, pos, n, a);
             assert(false);
         }
         catch (std::out_of_range&)
         {
#if TEST_STD_VER >= 11
     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
-  test2583();
-#endif
 #endif
 
   return true;
 }
 
 int main(int, char**)
 {
   test();
 #if TEST_STD_VER > 17
   // static_assert(test());
 #endif
 
+#ifndef TEST_HAS_NO_EXCEPTIONS
+  test2583();
+#endif
+
   return 0;
 }

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

 
 //   constexpr bool contains(charT x) const noexcept;
 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 
-void test()
+bool test()
 {
     using S = std::string;
 
     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'));
+
+    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.ptr.pass.cpp

 
 //   constexpr bool contains(const CharT *x) const;
 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 
-void test()
+bool test()
 {
     using S = std::string;
 
     const char* s = "abcde";
     S s0;
     S s1 {s + 4, 1};
     S s3 {s + 2, 3};
     S sNot {"xyz", 3};
bool test()
     assert(!sNot.contains("e"));
     assert(!sNot.contains("de"));
     assert(!sNot.contains("cd"));
     assert(!sNot.contains("cde"));
     assert(!sNot.contains("bcde"));
     assert(!sNot.contains("abcde"));
     assert( sNot.contains("xyz"));
     assert(!sNot.contains("zyx"));
+
+    return true;
 }
 
 int main(int, char**)
 {
   test();
 #if TEST_STD_VER > 17
   // static_assert(test());
 #endif
 
   return 0;
 }

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

 
 //   constexpr bool contains(basic_string_view x) const noexcept;
 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 
-void test()
+bool test()
 {
     using S = std::string;
     using SV = std::string_view;
 
     const char* s = "abcde";
     S s0;
     S s1 {s + 1, 1};
     S s3 {s + 1, 3};
bool test()
     assert(!sNot.contains(sv1));
     assert(!sNot.contains(sv2));
     assert(!sNot.contains(sv3));
     assert(!sNot.contains(sv4));
     assert(!sNot.contains(sv5));
     assert( sNot.contains(svNot));
     assert(!sNot.contains(svNot2));
     assert(!sNot.contains(svNot3));
+
+    return true;
 }
 
 int main(int, char**)
 {
   test();
 #if TEST_STD_VER > 17
   // static_assert(test());
 #endif
 
   return 0;
 }

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

 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S>
-void
+TEST_CONSTEXPR_CXX20 void
 test(const S& s)
 {
     typename S::const_iterator ce = s.cend();
     assert(ce == s.end());
 }
 
 bool test() {
   {

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

 #include <string>
 #include <cassert>
 #include <cstddef>
 
 #include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S>
-void
+TEST_CONSTEXPR_CXX20 void
 test(S s)
 {
     const S& cs = s;
     typename S::reverse_iterator e = s.rend();
     typename S::const_reverse_iterator ce = cs.rend();
     if (s.empty())
     {
         assert(e == s.rbegin());

libcxx/test/std/strings/basic.string/string.modifiers/robust_against_adl.pass.cpp

 #include "test_macros.h"
 
 struct Incomplete;
 template<class T> struct Holder { T t; };
 
 template<class T>
 struct Charlike {
     char ch_;
-    Charlike(char ch) : ch_(ch) {}
-    operator char() const { return ch_; }
+    TEST_CONSTEXPR Charlike(char ch) : ch_(ch) {}
+    TEST_CONSTEXPR operator char() const { return ch_; }
 };
 
 bool test() {
   std::string s;
   Charlike<Holder<Incomplete> > a[] = {'m', 'a', 'h', 'i'};
   s.append(a, a+4);
   s.assign(a, a+4);
   s.insert(s.begin(), a, a+4);

libcxx/test/std/strings/basic.string/string.modifiers/string_append/T_size_size.pass.cpp

 {
     if (pos <= sv.size())
     {
         s.append(sv, pos, n);
         LIBCPP_ASSERT(s.__invariants());
         assert(s == expected);
     }
 #ifndef TEST_HAS_NO_EXCEPTIONS
-    else
+    else if (!TEST_IS_CONSTANT_EVALUATED)
     {
         try
         {
             s.append(sv, pos, n);
             assert(false);
         }
         catch (std::out_of_range&)
         {

 {
     if (pos <= sv.size())
     {
         s.append(sv, pos);
         LIBCPP_ASSERT(s.__invariants());
         assert(s == expected);
     }
 #ifndef TEST_HAS_NO_EXCEPTIONS
-    else
+    else if (!TEST_IS_CONSTANT_EVALUATED)
     {
         try
         {
             s.append(sv, pos);
             assert(false);
         }
         catch (std::out_of_range&)
         {

libcxx/test/std/strings/basic.string/string.modifiers/string_append/iterator.pass.cpp

test(S("12345678901234567890"), cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+1),
          S("12345678901234567890""A"));
     test(S("12345678901234567890"), cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+10),
          S("12345678901234567890""ABCDEFGHIJ"));
     test(S("12345678901234567890"), cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+52),
          S("12345678901234567890""ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"));
   }
 #endif
 #ifndef TEST_HAS_NO_EXCEPTIONS
-  { // test iterator operations that throw
+  if (!TEST_IS_CONSTANT_EVALUATED) { // test iterator operations that throw
     typedef std::string S;
     typedef ThrowingIterator<char> TIter;
     typedef cpp17_input_iterator<TIter> IIter;
     const char* s = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
     test_exceptions(S(), IIter(TIter(s, s+10, 4, TIter::TAIncrement)), IIter(TIter()));
     test_exceptions(S(), IIter(TIter(s, s+10, 5, TIter::TADereference)), IIter(TIter()));
     test_exceptions(S(), IIter(TIter(s, s+10, 6, TIter::TAComparison)), IIter(TIter()));
 
#endif
     typedef std::string S;
     const uint8_t p[] = "ABCD";
 
     S s;
     s.append(p, p + 4);
     assert(s == "ABCD");
   }
 
-  { // regression-test appending to self in sneaky ways
+  if (!TEST_IS_CONSTANT_EVALUATED) { // regression-test appending to self in sneaky ways
     std::string s_short = "hello";
     std::string s_long = "Lorem ipsum dolor sit amet, consectetur/";
     std::string s_othertype = "hello";
     const unsigned char *first = reinterpret_cast<const unsigned char*>(s_othertype.data());
     std::string s_sneaky = "hello";
 
     test(s_short, s_short.data() + s_short.size(), s_short.data() + s_short.size() + 1,
          std::string("hello\0", 6));
     test(s_long, s_long.data() + s_long.size(), s_long.data() + s_long.size() + 1,
          std::string("Lorem ipsum dolor sit amet, consectetur/\0", 41));
     test(s_othertype, first + 2, first + 5, std::string("hellollo"));
 
     s_sneaky.reserve(12);
     test(s_sneaky, s_sneaky.data(), s_sneaky.data() + 6, std::string("hellohello\0", 11));
   }
 
   { // test with a move iterator that returns char&&
     typedef forward_iterator<const char*> It;
     typedef std::move_iterator<It> MoveIt;
     const char p[] = "ABCD";
     std::string s;
     s.append(MoveIt(It(std::begin(p))), MoveIt(It(std::end(p) - 1)));
     assert(s == "ABCD");

libcxx/test/std/strings/basic.string/string.modifiers/string_append/pointer.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, const typename S::value_type* str, S expected)
 {
     s.append(str);
     LIBCPP_ASSERT(s.__invariants());
     assert(s == expected);
 }
 
 bool test() {

libcxx/test/std/strings/basic.string/string.modifiers/string_append/string_size_size.pass.cpp

 {
     if (pos <= str.size())
     {
         s.append(str, pos, n);
         LIBCPP_ASSERT(s.__invariants());
         assert(s == expected);
     }
 #ifndef TEST_HAS_NO_EXCEPTIONS
-    else
+    else if (!TEST_IS_CONSTANT_EVALUATED)
     {
         try
         {
             s.append(str, pos, n);
             assert(false);
         }
         catch (std::out_of_range&)
         {

 {
     if (pos <= str.size())
     {
         s.append(str, pos);
         LIBCPP_ASSERT(s.__invariants());
         assert(s == expected);
     }
 #ifndef TEST_HAS_NO_EXCEPTIONS
-    else
+    else if (!TEST_IS_CONSTANT_EVALUATED)
     {
         try
         {
             s.append(str, pos);
             assert(false);
         }
         catch (std::out_of_range&)
         {

libcxx/test/std/strings/basic.string/string.modifiers/string_assign/T_size_size.pass.cpp

 #include <string>
 #include <stdexcept>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S, class SV>
-void
+TEST_CONSTEXPR_CXX20 void
 test(S s, SV sv, typename S::size_type pos, typename S::size_type n, S expected)
 {
     if (pos <= sv.size())
     {
         s.assign(sv, pos, n);
         LIBCPP_ASSERT(s.__invariants());
         assert(s == expected);
     }
 #ifndef TEST_HAS_NO_EXCEPTIONS
-    else
+    else if (!TEST_IS_CONSTANT_EVALUATED)
     {
         try
         {
             s.assign(sv, pos, n);
             assert(false);
         }
         catch (std::out_of_range&)
         {
             assert(pos > sv.size());
         }
     }
 #endif
 }
 
 template <class S, class SV>
-void
+TEST_CONSTEXPR_CXX20 void
 test_npos(S s, SV sv, typename S::size_type pos, S expected)
 {
     if (pos <= sv.size())
     {
         s.assign(sv, pos);
         LIBCPP_ASSERT(s.__invariants());
         assert(s == expected);
     }
 #ifndef TEST_HAS_NO_EXCEPTIONS
-    else
+    else if (!TEST_IS_CONSTANT_EVALUATED)
     {
         try
         {
             s.assign(sv, pos);
             assert(false);
         }
         catch (std::out_of_range&)
         {

libcxx/test/std/strings/basic.string/string.modifiers/string_assign/iterator.pass.cpp

 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 #include "test_iterators.h"
 #include "min_allocator.h"
 
 template <class S, class It>
-void
+TEST_CONSTEXPR_CXX20 void
 test(S s, It first, It last, S expected)
 {
     s.assign(first, last);
     LIBCPP_ASSERT(s.__invariants());
     assert(s == expected);
 }
 
 #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, It first, It last)
 {
     S original = s;
     typename S::iterator begin = s.begin();
     typename S::iterator end = s.end();
 
     try {
         s.assign(first, last);
test(S("12345678901234567890"), cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+1),
          S("A"));
     test(S("12345678901234567890"), cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+10),
          S("ABCDEFGHIJ"));
     test(S("12345678901234567890"), cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+52),
          S("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"));
   }
 #endif
 #ifndef TEST_HAS_NO_EXCEPTIONS
-  { // test iterator operations that throw
+  if (!TEST_IS_CONSTANT_EVALUATED) { // test iterator operations that throw
     typedef std::string S;
     typedef ThrowingIterator<char> TIter;
     typedef cpp17_input_iterator<TIter> IIter;
     const char* s = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
     test_exceptions(S(), IIter(TIter(s, s+10, 4, TIter::TAIncrement)), IIter(TIter()));
     test_exceptions(S(), IIter(TIter(s, s+10, 5, TIter::TADereference)), IIter(TIter()));
     test_exceptions(S(), IIter(TIter(s, s+10, 6, TIter::TAComparison)), IIter(TIter()));