Address philnik777's suggestions regarding libc++ test organizations

Author: winner245

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

@@ -12,12 +12,12 @@
 
 // void shrink_to_fit(); // constexpr since C++20
 
-// Make sure we use an allocation returned by allocate_at_least if it is smaller than the current allocation
-// even if it contains more bytes than we requested
-
 #include <cassert>
 #include <string>
 
+#include "asan_testing.h"
+#include "increasing_allocator.h"
+
 template <typename T>
 struct oversizing_allocator {
   using value_type       = T;
@@ -37,6 +37,9 @@ bool operator==(oversizing_allocator<T>, oversizing_allocator<U>) {
   return true;
 }
 
+// Make sure we use an allocation returned by allocate_at_least if it is smaller than the current allocation
+// even if it contains more bytes than we requested.
+// Fix issue: https://github.com/llvm/llvm-project/pull/115659
 void test_oversizing_allocator() {
   std::basic_string<char, std::char_traits<char>, oversizing_allocator<char>> s{
       "String does not fit in the internal buffer and is a bit longer"};
@@ -48,8 +51,37 @@ void test_oversizing_allocator() {
   assert(s.size() == size);
 }
 
+// Ensure that the libc++ implementation of shrink_to_fit does NOT swap buffer with equal allocation sizes
+void test_no_swap_with_equal_allocation_size() {
+  { // Test with custom allocator with a minimum allocation size
+    std::basic_string<char, std::char_traits<char>, min_size_allocator<128, char> > s(
+        "A long string exceeding SSO limit but within min alloc size");
+    std::size_t capacity = s.capacity();
+    std::size_t size     = s.size();
+    auto data            = s.data();
+    s.shrink_to_fit();
+    assert(s.capacity() <= capacity);
+    assert(s.size() == size);
+    assert(is_string_asan_correct(s));
+    assert(s.capacity() == capacity && s.data() == data);
+  }
+  { // Test with custom allocator with a minimum power of two allocation size
+    std::basic_string<char, std::char_traits<char>, pow2_allocator<char> > s(
+        "This is a long string that exceeds the SSO limit");
+    std::size_t capacity = s.capacity();
+    std::size_t size     = s.size();
+    auto data            = s.data();
+    s.shrink_to_fit();
+    assert(s.capacity() <= capacity);
+    assert(s.size() == size);
+    assert(is_string_asan_correct(s));
+    assert(s.capacity() == capacity && s.data() == data);
+  }
+}
+
 int main(int, char**) {
   test_oversizing_allocator();
+  test_no_swap_with_equal_allocation_size();
 
   return 0;
 }

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

@@ -75,33 +75,6 @@ TEST_CONSTEXPR_CXX20 bool test() {
   }
 #endif
 
-  {   // Ensure that the libc++ implementation of shrink_to_fit does NOT swap buffer with equal allocation sizes
-    { // Test with custom allocator with a minimum allocation size
-      std::basic_string<char, std::char_traits<char>, min_size_allocator<128, char> > s(
-          "A long string exceeding SSO limit but within min alloc size");
-      std::size_t capacity = s.capacity();
-      std::size_t size     = s.size();
-      auto data            = s.data();
-      s.shrink_to_fit();
-      assert(s.capacity() <= capacity);
-      assert(s.size() == size);
-      LIBCPP_ASSERT(is_string_asan_correct(s));
-      LIBCPP_ASSERT(s.capacity() == capacity && s.data() == data);
-    }
-    { // Test with custom allocator with a minimum power of two allocation size
-      std::basic_string<char, std::char_traits<char>, pow2_allocator<char> > s(
-          "This is a long string that exceeds the SSO limit");
-      std::size_t capacity = s.capacity();
-      std::size_t size     = s.size();
-      auto data            = s.data();
-      s.shrink_to_fit();
-      assert(s.capacity() <= capacity);
-      assert(s.size() == size);
-      LIBCPP_ASSERT(is_string_asan_correct(s));
-      LIBCPP_ASSERT(s.capacity() == capacity && s.data() == data);
-    }
-  }
-
   return true;
 }
 

libcxx/test/support/increasing_allocator.h

@@ -59,14 +59,6 @@ class min_size_allocator {
   template <typename U>
   TEST_CONSTEXPR_CXX20 min_size_allocator(const min_size_allocator<MinAllocSize, U>&) TEST_NOEXCEPT {}
 
-#if TEST_STD_VER >= 23
-  TEST_CONSTEXPR_CXX23 std::allocation_result<T*> allocate_at_least(std::size_t n) {
-    if (n < MinAllocSize)
-      n = MinAllocSize;
-    return std::allocator<T>{}.allocate_at_least(n);
-  }
-#endif // TEST_STD_VER >= 23
-
   TEST_NODISCARD TEST_CONSTEXPR_CXX20 T* allocate(std::size_t n) {
     if (n < MinAllocSize)
       n = MinAllocSize;
@@ -102,12 +94,6 @@ class pow2_allocator {
   template <typename U>
   TEST_CONSTEXPR_CXX20 pow2_allocator(const pow2_allocator<U>&) TEST_NOEXCEPT {}
 
-#if TEST_STD_VER >= 23
-  TEST_CONSTEXPR_CXX23 std::allocation_result<T*> allocate_at_least(std::size_t n) {
-    return std::allocator<T>{}.allocate_at_least(next_power_of_two(n));
-  }
-#endif // TEST_STD_VER >= 23
-
   TEST_NODISCARD TEST_CONSTEXPR_CXX20 T* allocate(std::size_t n) {
     return std::allocator<T>().allocate(next_power_of_two(n));
   }