Add comment for increasing_allocator

Author: winner245

libcxx/test/support/increasing_allocator.h

@@ -6,38 +6,56 @@
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef INCREASING_ALLOCATOR_H
-#define INCREASING_ALLOCATOR_H
+#ifndef TEST_SUPPORT_INCREASING_ALLOCATOR_H
+#define TEST_SUPPORT_INCREASING_ALLOCATOR_H
 
 #include <cstddef>
 #include <memory>
 
 #include "test_macros.h"
 
-#if TEST_STD_VER >= 23
+// The increasing_allocator is a custom allocator that enforces an increasing minimum allocation size, 
+// ensuring that it allocates an increasing amount of memory, possibly exceeding the requested amount.
+// This unique behavior is particularly useful for testing the shrink_to_fit functionality in std::vector, 
+// vector<bool>, and std::basic_string, ensuring that shrink_to_fit does not increase the capacity of 
+// the allocated memory.
+
 template <typename T>
 struct increasing_allocator {
   using value_type         = T;
   std::size_t min_elements = 1000;
   increasing_allocator()   = default;
 
   template <typename U>
-  constexpr increasing_allocator(const increasing_allocator<U>& other) noexcept : min_elements(other.min_elements) {}
+  TEST_CONSTEXPR_CXX20 increasing_allocator(const increasing_allocator<U>& other) TEST_NOEXCEPT
+      : min_elements(other.min_elements) {}
 
-  constexpr std::allocation_result<T*> allocate_at_least(std::size_t n) {
+#if TEST_STD_VER >= 23
+  TEST_CONSTEXPR_CXX23 std::allocation_result<T*> allocate_at_least(std::size_t n) {
     if (n < min_elements)
       n = min_elements;
     min_elements += 1000;
     return std::allocator<T>{}.allocate_at_least(n);
   }
-  constexpr T* allocate(std::size_t n) { return std::allocator<T>{}.allocate(n); }
-  constexpr void deallocate(T* p, std::size_t n) noexcept { std::allocator<T>{}.deallocate(p, n); }
+#endif // TEST_STD_VER >= 23
+
+  TEST_CONSTEXPR_CXX20 T* allocate(std::size_t n) {
+#if TEST_STD_VER >= 23
+    return allocate_at_least(n).ptr;
+#else
+    if (n < min_elements)
+      n = min_elements;
+    min_elements += 1000;
+    return std::allocator<T>{}.allocate(n);
+#endif
+  }
+
+  TEST_CONSTEXPR_CXX20 void deallocate(T* p, std::size_t n) TEST_NOEXCEPT { std::allocator<T>{}.deallocate(p, n); }
 };
 
 template <typename T, typename U>
-bool operator==(increasing_allocator<T>, increasing_allocator<U>) {
+TEST_CONSTEXPR_CXX20 bool operator==(increasing_allocator<T>, increasing_allocator<U>) TEST_NOEXCEPT {
   return true;
 }
-#endif // TEST_STD_VER >= 23
 
-#endif // INCREASING_ALLOCATOR_H
+#endif // TEST_SUPPORT_INCREASING_ALLOCATOR_H