[libc++] Prepare string.{contains, ends_with, iterators, require, starts_with} tests for constexpr

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

void test()
     assert(!s1.contains('x'));
     assert( s2.contains('c'));
     assert( s2.contains('e'));
     assert(!s2.contains('x'));
 }
 
 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

void test()
     assert(!sNot.contains("bcde"));
     assert(!sNot.contains("abcde"));
     assert( sNot.contains("xyz"));
     assert(!sNot.contains("zyx"));
 }
 
 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

void test()
     assert(!sNot.contains(sv5));
     assert( sNot.contains(svNot));
     assert(!sNot.contains(svNot2));
     assert(!sNot.contains(svNot3));
 }
 
 int main(int, char**)
 {
-    test();
+#if TEST_STD_VER > 17
+  // static_assert(test());
+#endif
 
-    return 0;
 }

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

 
 //   bool ends_with(charT x) const noexcept;
 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 
-int main(int, char**)
-{
-    {
+bool test() {
     typedef std::string S;
     S  s1 {};
     S  s2 { "abcde", 5 };
 
     ASSERT_NOEXCEPT(s1.ends_with('e'));
 
     assert (!s1.ends_with('e'));
     assert (!s1.ends_with('x'));
     assert ( s2.ends_with('e'));
     assert (!s2.ends_with('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.ends_with/ends_with.ptr.pass.cpp

 
 //   bool ends_with(const CharT *x) const;
 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 
-int main(int, char**)
-{
-    {
+bool test() {
     typedef std::string S;
     const char *s = "abcde";
 
     S   s0;
     S   s1  { s + 4, 1 };
     S   s2  { s + 3, 2 };
 //  S   s3  { s + 2, 3 };
 //  S   s4  { s + 1, 4 };
//  S   s5  { s,     5 };
 
     assert ( sNot.ends_with(""));
     assert (!sNot.ends_with("e"));
     assert (!sNot.ends_with("de"));
     assert (!sNot.ends_with("cde"));
     assert (!sNot.ends_with("bcde"));
     assert (!sNot.ends_with("abcde"));
     assert ( sNot.ends_with("def"));
-    }
 
+  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.ends_with/ends_with.string_view.pass.cpp

 
 //   bool ends_with(basic_string_view x) const noexcept;
 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 
-int main(int, char**)
-{
-    {
+bool test() {
     typedef std::string S;
     typedef std::string_view SV;
     const char *s = "abcde";
 
     S   s0;
     S   s1  { s + 4, 1 };
     S   s2  { s + 3, 2 };
 //  S   s3  { s + 2, 3 };
//  S   s5  { s,     5 };
 
     assert ( sNot.ends_with(sv0));
     assert (!sNot.ends_with(sv1));
     assert (!sNot.ends_with(sv2));
     assert (!sNot.ends_with(sv3));
     assert (!sNot.ends_with(sv4));
     assert (!sNot.ends_with(sv5));
     assert ( sNot.ends_with(svNot));
-    }
 
+  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/begin.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)
 {
     const S& cs = s;
     typename S::iterator b = s.begin();
     typename S::const_iterator cb = cs.begin();
     if (!s.empty())
     {
         assert(*b == s[0]);
     }
     assert(b == cb);
 }
 
-int main(int, char**)
-{
-    {
+bool test() {
     typedef std::string S;
     test(S());
     test(S("123"));
-    }
 #if TEST_STD_VER >= 11
-    {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test(S());
     test(S("123"));
-    }
 #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.iterators/cbegin.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 cb = s.cbegin();
     if (!s.empty())
     {
         assert(*cb == s[0]);
     }
     assert(cb == s.begin());
 }
 
-int main(int, char**)
-{
-    {
+bool test() {
     typedef std::string S;
     test(S());
     test(S("123"));
-    }
 #if TEST_STD_VER >= 11
-    {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test(S());
     test(S("123"));
-    }
 #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.iterators/cend.pass.cpp

 template <class S>
 void
 test(const S& s)
 {
     typename S::const_iterator ce = s.cend();
     assert(ce == s.end());
 }
 
-int main(int, char**)
-{
-    {
+bool test() {
     typedef std::string S;
     test(S());
     test(S("123"));
-    }
 #if TEST_STD_VER >= 11
-    {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test(S());
     test(S("123"));
-    }
 #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.iterators/crbegin.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_reverse_iterator cb = s.crbegin();
     if (!s.empty())
     {
         assert(*cb == s.back());
     }
     assert(cb == s.rbegin());
 }
 
-int main(int, char**)
-{
-    {
+bool test() {
     typedef std::string S;
     test(S());
     test(S("123"));
-    }
 #if TEST_STD_VER >= 11
-    {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test(S());
     test(S("123"));
-    }
 #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.iterators/crend.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_reverse_iterator ce = s.crend();
     assert(ce == s.rend());
 }
 
-int main(int, char**)
-{
-    {
+bool test() {
     typedef std::string S;
     test(S());
     test(S("123"));
-    }
 #if TEST_STD_VER >= 11
-    {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test(S());
     test(S("123"));
-    }
 #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.iterators/end.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::iterator e = s.end();
     typename S::const_iterator ce = cs.end();
     if (s.empty())
     {
         assert(e == s.begin());
         assert(ce == cs.begin());
     }
     assert(static_cast<std::size_t>(e - s.begin()) == s.size());
     assert(static_cast<std::size_t>(ce - cs.begin()) == cs.size());
 }
 
-int main(int, char**)
-{
-    {
+bool test() {
     typedef std::string S;
     test(S());
     test(S("123"));
-    }
 #if TEST_STD_VER >= 11
-    {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test(S());
     test(S("123"));
-    }
 #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.iterators/rbegin.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)
 {
     const S& cs = s;
     typename S::reverse_iterator b = s.rbegin();
     typename S::const_reverse_iterator cb = cs.rbegin();
     if (!s.empty())
     {
         assert(*b == s.back());
     }
     assert(b == cb);
 }
 
-int main(int, char**)
-{
-    {
+bool test() {
     typedef std::string S;
     test(S());
     test(S("123"));
-    }
 #if TEST_STD_VER >= 11
-    {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test(S());
     test(S("123"));
-    }
 #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.iterators/rend.pass.cpp

test(S s)
     {
         assert(e == s.rbegin());
         assert(ce == cs.rbegin());
     }
     assert(static_cast<std::size_t>(e - s.rbegin()) == s.size());
     assert(static_cast<std::size_t>(ce - cs.rbegin()) == cs.size());
 }
 
-int main(int, char**)
-{
-    {
+bool test() {
     typedef std::string S;
     test(S());
     test(S("123"));
-    }
 #if TEST_STD_VER >= 11
-    {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     test(S());
     test(S("123"));
-    }
 #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.require/contiguous.pass.cpp

 
 template <class C>
 void test_contiguous ( const C &c )
 {
     for ( size_t i = 0; i < c.size(); ++i )
         assert ( *(c.begin() + static_cast<typename C::difference_type>(i)) == *(std::addressof(*c.begin()) + i));
 }
 
-int main(int, char**)
-{
-    {
+bool test() {
     typedef std::string S;
     test_contiguous(S());
     test_contiguous(S("1"));
     test_contiguous(S("1234567890123456789012345678901234567890123456789012345678901234567890"));
-    }
 
-    {
     typedef test_allocator<char> A;
     typedef std::basic_string<char, std::char_traits<char>, A> S;
     test_contiguous(S(A(3)));
     test_contiguous(S("1", A(5)));
     test_contiguous(S("1234567890123456789012345678901234567890123456789012345678901234567890", A(7)));
-    }
 #if TEST_STD_VER >= 11
-    {
     typedef min_allocator<char> A;
     typedef std::basic_string<char, std::char_traits<char>, A> S;
     test_contiguous(S(A{}));
     test_contiguous(S("1", A()));
     test_contiguous(S("1234567890123456789012345678901234567890123456789012345678901234567890", A()));
-    }
 #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

 
 //   bool starts_with(charT x) const noexcept;
 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 
-int main(int, char**)
-{
-    {
+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/std/strings/basic.string/string.starts_with/starts_with.ptr.pass.cpp

 
 //   bool starts_with(const CharT *x) const;
 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 
-int main(int, char**)
-{
-    {
+bool test() {
     typedef std::string S;
     const char *s = "abcde";
     S  s0 {};
     S  s1 { s, 1 };
     S  s2 { s, 2 };
 //     S  s3 { s, 3 };
 //     S  s4 { s, 4 };
 //     S  s5 { s, 5 };
//     S  s5 { s, 5 };
 
     assert ( sNot.starts_with(""));
     assert (!sNot.starts_with("a"));
     assert (!sNot.starts_with("ab"));
     assert (!sNot.starts_with("abc"));
     assert (!sNot.starts_with("abcd"));
     assert (!sNot.starts_with("abcde"));
     assert ( sNot.starts_with("def"));
-    }
 
+  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.string_view.pass.cpp

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