[libc++] Use stack buffers for uninitialized storage in tests.

[var-const]

Summary

This makes the tests more minimal, and in particular it avoids relying on a complete <cstdlib>, which may not be available on all platforms.

[philnik]

LGTM with the alignment bug fixed.

libcxx/test/std/utilities/utility/mem.res/mem.poly.allocator.class/mem.poly.allocator.mem/construct_pair.pass.cpp

40–42

You could instead do

union { P p; };
a.construct(&p);

That would fix the alignment bug and avoid a reinterpret_cast.

[var-const]

Fix alignment.

[var-const]

libcxx/test/std/utilities/utility/mem.res/mem.poly.allocator.class/mem.poly.allocator.mem/construct_pair.pass.cpp

40–42

That doesn't work because the default constructors in question are non-trivial. How about using alignas instead?

[philnik]

libcxx/test/std/utilities/utility/mem.res/mem.poly.allocator.class/mem.poly.allocator.mem/construct_pair.pass.cpp

40–42

Ah, I missed that. Then alignas is probably the correct call.

libcxx/test/std/utilities/utility/mem.res/mem.poly.allocator.class/mem.poly.allocator.mem/construct_pair.pass.cpp

 
 // template <class T> class polymorphic_allocator
 
 // template <class U1, class U2>
 // void polymorphic_allocator<T>::construct(pair<U1, U2>*)
 
 #include <memory_resource>
 #include <cassert>
-#include <cstdlib>
 #include <tuple>
 #include <type_traits>
 #include <utility>
 #include "uses_alloc_types.h"
 
 int constructed = 0;
 
 struct default_constructible {
   default_constructible() : x(42) { ++constructed; }
   int x = 0;
 };
 
 int main(int, char**) {
   // pair<default_constructible, default_constructible> as T()
   {
     typedef default_constructible T;
     typedef std::pair<T, T> P;
     typedef std::pmr::polymorphic_allocator<void> A;
-    P* ptr = (P*)std::malloc(sizeof(P));
+    alignas(P) char buffer[sizeof(P)];
+    P* ptr = reinterpret_cast<P*>(buffer);
     A a;
     a.construct(ptr);
     assert(constructed == 2);
     assert(ptr->first.x == 42);
     assert(ptr->second.x == 42);
-    std::free(ptr);
   }
 
   return 0;
 }

libcxx/test/std/utilities/utility/mem.res/mem.poly.allocator.class/mem.poly.allocator.mem/construct_piecewise_pair_evil.pass.cpp

 // void polymorphic_allocator<T>::construct(pair<U1, U2>*, piecewise_construct_t
 //                                          tuple<Args1...>, tuple<Args2...>)
 
 #include <memory_resource>
 #include <tuple>
 #include <type_traits>
 #include <utility>
 #include <cassert>
-#include <cstdlib>
 
 #include "test_macros.h"
 
 template <class T>
 struct EvilAlloc {
   explicit EvilAlloc() : inner_(std::pmr::null_memory_resource()) {}
 
   EvilAlloc(std::pmr::polymorphic_allocator<T>& a) : inner_(a) {}

 static_assert(std::uses_allocator<WidgetV3, std::pmr::polymorphic_allocator<char>>::value, "");
 
 template <class W1, class W2>
 void test_evil() {
   using PMA = std::pmr::polymorphic_allocator<char>;
   PMA pma(std::pmr::new_delete_resource());
   {
     using Pair  = std::pair<W1, W2>;
-    void* where = std::malloc(sizeof(Pair));
-    Pair* p     = (Pair*)where;
+    alignas(Pair) char buffer[sizeof(Pair)];
+    Pair* p = reinterpret_cast<Pair*>(buffer);
     pma.construct(p, std::piecewise_construct, std::make_tuple(42), std::make_tuple(42));
     assert(p->first.holds(42, pma));
     assert(p->second.holds(42, pma));
     pma.destroy(p);
-    std::free(where);
   }
 }
 
 int main(int, char**) {
   test_evil<WidgetV0, WidgetV0>();
   test_evil<WidgetV0, WidgetV1>();
   test_evil<WidgetV0, WidgetV2>();
   test_evil<WidgetV0, WidgetV3>();

libcxx/test/std/utilities/utility/mem.res/mem.poly.allocator.class/mem.poly.allocator.mem/destroy.pass.cpp

 
 // template <class T> class polymorphic_allocator
 
 // template <class U>
 // void polymorphic_allocator<T>::destroy(U * ptr);
 
 #include <memory_resource>
 #include <cassert>
-#include <cstdlib>
 #include <new>
 #include <type_traits>
 
 #include "test_macros.h"
 
 int count = 0;
 
 struct destroyable {
   destroyable() { ++count; }
   ~destroyable() { --count; }
 };
 
 int main(int, char**) {
   typedef std::pmr::polymorphic_allocator<double> A;
   {
     A a;
     ASSERT_SAME_TYPE(decltype(a.destroy((destroyable*)nullptr)), void);
   }
   {
-    destroyable* ptr = ::new (std::malloc(sizeof(destroyable))) destroyable();
+    alignas(destroyable) char buffer[sizeof(destroyable)];
+    destroyable* ptr = ::new (buffer) destroyable();
     assert(count == 1);
     A{}.destroy(ptr);
     assert(count == 0);
-    std::free(ptr);
   }
 
   return 0;
 }