[libc++] Enable libc++-specific tests for constexpr string

[ldionne]

libcxx/test/libcxx/strings/basic.string/PR42676.sh.cpp

29 ↗

(On Diff #439968)

#if TEST_STD_VER > xxx

[philnik]

• Try to fix CI

[Mordante]

LGTM after the CI passes!

[philnik]

Rebased

[philnik]

• Fix CI

libcxx/include/string

void __copy_assign_alloc(const basic_string& __str, true_type)
                     __clear_and_shrink();
                     __alloc() = __str.__alloc();
                 }
                 else
                 {
                     allocator_type __a = __str.__alloc();
                     auto __allocation = std::__allocate_at_least(__a, __str.__get_long_cap());
                     __begin_lifetime(__allocation.ptr, __allocation.count);
-                    __clear_and_shrink();
+                    __alloc_traits::deallocate(__alloc(), __get_long_pointer(), __get_long_cap());
                     __alloc() = std::move(__a);
                     __set_long_pointer(__allocation.ptr);
                     __set_long_cap(__allocation.count);
                     __set_long_size(__str.size());
                 }
             }
         }
 

 inline _LIBCPP_CONSTEXPR_SINCE_CXX20
 void
 basic_string<_CharT, _Traits, _Allocator>::__clear_and_shrink() _NOEXCEPT
 {
     clear();
     if(__is_long())
     {
         __alloc_traits::deallocate(__alloc(), __get_long_pointer(), capacity() + 1);
-        __set_long_cap(0);
-        __set_short_size(0);
-        traits_type::assign(*__get_short_pointer(), value_type());
+        __default_init();
     }
 }
 
 // operator==
 
 template<class _CharT, class _Traits, class _Allocator>
 inline _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI
 bool

libcxx/test/libcxx/strings/basic.string/string.capacity/PR53170.pass.cpp

 #include <string>
 #include <stdexcept>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S>
-void test() {
+TEST_CONSTEXPR_CXX20 bool test() {
     // Test that a call to reserve() does shrink the string.
-    {
+    if (!TEST_IS_CONSTANT_EVALUATED) {
         S s(1000, 'a');
         typename S::size_type old_cap = s.capacity();
         s.resize(20);
         assert(s.capacity() == old_cap);
 
         s.reserve();
         assert(s.capacity() < old_cap);
     }
// In particular, test that reserve(0) does NOT shrink the string.
         S s(1000, 'a');
         typename S::size_type old_cap = s.capacity();
         s.resize(20);
         assert(s.capacity() == old_cap);
 
         s.reserve(0);
         assert(s.capacity() == old_cap);
     }
+
+    return true;
 }
 
 int main(int, char**) {
     test<std::string>();
 
 #if TEST_STD_VER >= 11
     test<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
 #endif
 
+#if TEST_STD_VER > 17
+    static_assert(test<std::string>());
+#endif
+
     return 0;
 }

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

 #include <cstddef>
 #include <string>
 
 #include "test_macros.h"
 
 // alignment of the string heap buffer is hardcoded to 16
 static const size_t alignment = 16;
 
-void full_size() {
+TEST_CONSTEXPR_CXX20 void full_size() {
   std::string str;
   assert(str.max_size() == std::numeric_limits<size_t>::max() - alignment);
 
 #ifndef TEST_HAS_NO_CHAR8_T
   std::u8string u8str;
   assert(u8str.max_size() == std::numeric_limits<size_t>::max() - alignment);
 #endif
 
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
   std::wstring wstr;
   assert(wstr.max_size() == std::numeric_limits<size_t>::max() / sizeof(wchar_t) - alignment);
 #endif
 
   std::u16string u16str;
   std::u32string u32str;
   assert(u16str.max_size() == std::numeric_limits<size_t>::max() / 2 - alignment);
   assert(u32str.max_size() == std::numeric_limits<size_t>::max() / 4 - alignment);
 }
 
-void half_size() {
+TEST_CONSTEXPR_CXX20 void half_size() {
   std::string str;
   assert(str.max_size() == std::numeric_limits<size_t>::max() / 2 - alignment);
 
 #ifndef TEST_HAS_NO_CHAR8_T
   std::u8string u8str;
   assert(u8str.max_size() == std::numeric_limits<size_t>::max() / 2 - alignment);
 #endif
 
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
   std::wstring wstr;
   assert(wstr.max_size() == std::numeric_limits<size_t>::max() / std::max<size_t>(2ul, sizeof(wchar_t)) - alignment);
 #endif
 
   std::u16string u16str;
   std::u32string u32str;
   assert(u16str.max_size() == std::numeric_limits<size_t>::max() / 2 - alignment);
   assert(u32str.max_size() == std::numeric_limits<size_t>::max() / 4 - alignment);
 }
 
-bool test() {
+TEST_CONSTEXPR_CXX20 bool test() {
 
 #if _LIBCPP_ABI_VERSION == 1
 
 # if defined(__x86_64__) || defined(__i386__)
   full_size();
 # elif defined(__APPLE__) && defined(__aarch64__)
   half_size();
 # elif defined(__arm__) || defined(__aarch64__)

 #endif
 
   return true;
 }
 
 int main(int, char**) {
   test();
 #if TEST_STD_VER > 17
-  // static_assert(test());
+  static_assert(test());
 #endif
 
   return 0;
 }

libcxx/test/libcxx/strings/basic.string/string.cons/copy_shrunk_long.pass.cpp

 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 #include "test_allocator.h"
 #include "min_allocator.h"
 
 template <class S>
-void
-test()
+TEST_CONSTEXPR_CXX20 bool test()
 {
   // Tests that a long string holding a SSO size string results in
   // an SSO copy constructed value.
   S s1("1234567890123456789012345678901234567890123456789012345678901234567890");
   s1.resize(7);
   S s2(s1);
   LIBCPP_ASSERT(s2.__invariants());
   assert(s2 == s1);
   assert(s2.capacity() < sizeof(S));
+
+  return true;
 }
 
 int main(int, char**)
 {
-    {
-    typedef test_allocator<char> A;
-    typedef std::basic_string<char, std::char_traits<char>, A> S;
-    test<S>();
-    }
+  test<std::basic_string<char, std::char_traits<char>, test_allocator<char> > >();
 #if TEST_STD_VER >= 11
-    {
-    typedef min_allocator<char> A;
-    typedef std::basic_string<char, std::char_traits<char>, A> S;
-    test<S>();
-    }
+  test<std::basic_string<char, std::char_traits<char>, min_allocator<char>>>();
+#endif
+#if TEST_STD_VER > 17
+  static_assert(test<std::basic_string<char, std::char_traits<char>, test_allocator<char>>>());
+  static_assert(test<std::basic_string<char, std::char_traits<char>, min_allocator<char>>>());
 #endif
 
   return 0;
 }

libcxx/test/libcxx/strings/basic.string/string.modifiers/clear_and_shrink.pass.cpp

 
 // Call __clear_and_shrink() and ensure string invariants hold
 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 
-int main(int, char**)
-{
-    std::string l = "Long string so that allocation definitely, for sure, absolutely happens. Probably.";
-    std::string s = "short";
+TEST_CONSTEXPR_CXX20 bool test() {
 
-    assert(l.__invariants());
-    assert(s.__invariants());
 
-    s.__clear_and_shrink();
-    assert(s.__invariants());
-    assert(s.size() == 0);
 
-    {
-    std::string::size_type cap = l.capacity();
-    l.__clear_and_shrink();
-    assert(l.__invariants());
-    assert(l.size() == 0);
-    assert(l.capacity() < cap);
-    }
+
+  return true;
 
-    return 0;
+int main(int, char**)
+{
+  test();
+#if TEST_STD_VER > 17
+  static_assert(test());
+#endif
 }

libcxx/test/libcxx/strings/basic.string/string.modifiers/resize_default_initialized.pass.cpp

 
 // __resize_default_init(size_type)
 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 
-void write_c_str(char *buf, int size) {
+TEST_CONSTEXPR_CXX20 void write_c_str(char *buf, int size) {
   for (int i=0; i < size; ++i) {
     buf[i] = 'a';
   }
   buf[size] = '\0';
 }
 
-void test_buffer_usage()
+TEST_CONSTEXPR_CXX20 void test_buffer_usage()
 {
   {
     unsigned buff_size = 125;
     unsigned used_size = buff_size - 16;
     std::string s;
     s.__resize_default_init(buff_size);
     write_c_str(&s[0], used_size);
     assert(s.size() == buff_size);
-    assert(strlen(s.data()) == used_size);
+    assert(std::char_traits<char>().length(s.data()) == used_size);
     s.__resize_default_init(used_size);
     assert(s.size() == used_size);
     assert(s.data()[used_size] == '\0');
     for (unsigned i=0; i < used_size; ++i) {
       assert(s[i] == 'a');
     }
   }
 }
 
-void test_basic() {
+TEST_CONSTEXPR_CXX20 void test_basic() {
   {
     std::string s;
     s.__resize_default_init(3);
     assert(s.size() == 3);
     assert(s.data()[3] == '\0');
     for (int i=0; i < 3; ++i)
       s[i] = 'a' + i;
     s.__resize_default_init(1);
     assert(s[0] == 'a');
     assert(s.data()[1] == '\0');
     assert(s.size() == 1);
   }
 }
 
-int main(int, char**) {
+TEST_CONSTEXPR_CXX20 bool test() {
   test_basic();
   test_buffer_usage();
 
+  return true;
+}
+
+int main(int, char**) {
+  test();
+#if TEST_STD_VER > 17
+  static_assert(test());
+#endif
+
   return 0;
 }