Vendor import of libc++ trunk r290819:vendor/libc++/libc++-trunk-r290819

https://llvm.org/svn/llvm-project/libcxx/trunk@290819

29 files changed, 937 insertions, 78 deletions

diff --git a/test/std/utilities/allocator.adaptor/allocator.adaptor.cnstr/allocs.pass.cpp b/test/std/utilities/allocator.adaptor/allocator.adaptor.cnstr/allocs.pass.cpp
index a5663a2e063e..0aef2af85ccf 100644
--- a/test/std/utilities/allocator.adaptor/allocator.adaptor.cnstr/allocs.pass.cpp
+++ b/test/std/utilities/allocator.adaptor/allocator.adaptor.cnstr/allocs.pass.cpp
@@ -7,6 +7,8 @@
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: c++98, c++03
+
 // <memory>
 
 // template <class OuterAlloc, class... InnerAllocs>
@@ -23,8 +25,6 @@
 
 int main()
 {
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
-
     {
         typedef std::scoped_allocator_adaptor<A1<int>> A;
         A1<int> a3(3);
@@ -108,5 +108,4 @@ int main()
             std::scoped_allocator_adaptor<A2<int>, A3<int>>(A2<int>(5), A3<int>(6))));
     }
 
-#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 }
diff --git a/test/std/utilities/allocator.adaptor/allocator.adaptor.cnstr/converting_copy.pass.cpp b/test/std/utilities/allocator.adaptor/allocator.adaptor.cnstr/converting_copy.pass.cpp
index 9d40cf55a144..8fbbcebe1268 100644
--- a/test/std/utilities/allocator.adaptor/allocator.adaptor.cnstr/converting_copy.pass.cpp
+++ b/test/std/utilities/allocator.adaptor/allocator.adaptor.cnstr/converting_copy.pass.cpp
@@ -7,6 +7,8 @@
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: c++98, c++03
+
 // <memory>
 
 // template <class OuterAlloc, class... InnerAllocs>
@@ -23,8 +25,6 @@
 
 int main()
 {
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
-
     {
         typedef std::scoped_allocator_adaptor<A1<double>> B;
         typedef std::scoped_allocator_adaptor<A1<int>> A;
@@ -65,5 +65,4 @@ int main()
         assert(a2 == a1);
     }
 
-#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 }
diff --git a/test/std/utilities/allocator.adaptor/allocator.adaptor.cnstr/converting_move.pass.cpp b/test/std/utilities/allocator.adaptor/allocator.adaptor.cnstr/converting_move.pass.cpp
index 02e9dff7d7d3..8b585e5f6243 100644
--- a/test/std/utilities/allocator.adaptor/allocator.adaptor.cnstr/converting_move.pass.cpp
+++ b/test/std/utilities/allocator.adaptor/allocator.adaptor.cnstr/converting_move.pass.cpp
@@ -7,6 +7,8 @@
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: c++98, c++03
+
 // <memory>
 
 // template <class OuterAlloc, class... InnerAllocs>
@@ -23,8 +25,6 @@
 
 int main()
 {
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
-
     {
         typedef std::scoped_allocator_adaptor<A1<double>> B;
         typedef std::scoped_allocator_adaptor<A1<int>> A;
@@ -70,6 +70,4 @@ int main()
         assert(A3<int>::move_called == true);
         assert(a2 == a1);
     }
-
-#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 }
diff --git a/test/std/utilities/allocator.adaptor/allocator.adaptor.cnstr/copy.pass.cpp b/test/std/utilities/allocator.adaptor/allocator.adaptor.cnstr/copy.pass.cpp
index 21055325112f..86f16891ac3c 100644
--- a/test/std/utilities/allocator.adaptor/allocator.adaptor.cnstr/copy.pass.cpp
+++ b/test/std/utilities/allocator.adaptor/allocator.adaptor.cnstr/copy.pass.cpp
@@ -7,6 +7,8 @@
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: c++98, c++03
+
 // <memory>
 
 // template <class OuterAlloc, class... InnerAllocs>
@@ -21,8 +23,6 @@
 
 int main()
 {
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
-
     {
         typedef std::scoped_allocator_adaptor<A1<int>> A;
         A a1(A1<int>(3));
@@ -65,6 +65,4 @@ int main()
         assert(A3<int>::move_called == false);
         assert(a2 == a1);
     }
-
-#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 }
diff --git a/test/std/utilities/allocator.adaptor/allocator.adaptor.cnstr/default.pass.cpp b/test/std/utilities/allocator.adaptor/allocator.adaptor.cnstr/default.pass.cpp
index 2a1d781eb9cd..b335935e333d 100644
--- a/test/std/utilities/allocator.adaptor/allocator.adaptor.cnstr/default.pass.cpp
+++ b/test/std/utilities/allocator.adaptor/allocator.adaptor.cnstr/default.pass.cpp
@@ -7,6 +7,8 @@
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: c++98, c++03
+
 // <memory>
 
 // template <class OuterAlloc, class... InnerAllocs>
@@ -21,8 +23,6 @@
 
 int main()
 {
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
-
     {
         typedef std::scoped_allocator_adaptor<A1<int>> A;
         A a;
@@ -54,5 +54,4 @@ int main()
         assert(A3<int>::move_called == false);
     }
 
-#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 }
diff --git a/test/std/utilities/allocator.adaptor/allocator.adaptor.members/allocate_size.pass.cpp b/test/std/utilities/allocator.adaptor/allocator.adaptor.members/allocate_size.pass.cpp
index 727907e3ec76..dd8cf4273272 100644
--- a/test/std/utilities/allocator.adaptor/allocator.adaptor.members/allocate_size.pass.cpp
+++ b/test/std/utilities/allocator.adaptor/allocator.adaptor.members/allocate_size.pass.cpp
@@ -7,6 +7,8 @@
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: c++98, c++03
+
 // <memory>
 
 // template <class OuterAlloc, class... InnerAllocs>
@@ -21,8 +23,6 @@
 
 int main()
 {
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
-
     {
         typedef std::scoped_allocator_adaptor<A1<int>> A;
         A a;
@@ -45,5 +45,4 @@ int main()
         assert(A1<int>::allocate_called == true);
     }
 
-#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 }
diff --git a/test/std/utilities/allocator.adaptor/allocator.adaptor.members/allocate_size_hint.pass.cpp b/test/std/utilities/allocator.adaptor/allocator.adaptor.members/allocate_size_hint.pass.cpp
index cae42de66905..f5ce83aa4f6c 100644
--- a/test/std/utilities/allocator.adaptor/allocator.adaptor.members/allocate_size_hint.pass.cpp
+++ b/test/std/utilities/allocator.adaptor/allocator.adaptor.members/allocate_size_hint.pass.cpp
@@ -7,6 +7,8 @@
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: c++98, c++03
+
 // <memory>
 
 // template <class OuterAlloc, class... InnerAllocs>
@@ -21,8 +23,6 @@
 
 int main()
 {
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
-
     {
         typedef std::scoped_allocator_adaptor<A1<int>> A;
         A a;
@@ -66,5 +66,4 @@ int main()
         assert(a.allocate(10, (const void*)20) == (int*)20);
         assert(A2<int>::allocate_called == true);
     }
-#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 }
diff --git a/test/std/utilities/allocator.adaptor/allocator.adaptor.members/construct.pass.cpp b/test/std/utilities/allocator.adaptor/allocator.adaptor.members/construct.pass.cpp
index f94b0e19ac90..dc629edec54a 100644
--- a/test/std/utilities/allocator.adaptor/allocator.adaptor.members/construct.pass.cpp
+++ b/test/std/utilities/allocator.adaptor/allocator.adaptor.members/construct.pass.cpp
@@ -7,6 +7,8 @@
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: c++98, c++03
+
 // <memory>
 
 // template <class OuterAlloc, class... InnerAllocs>
@@ -20,8 +22,6 @@
 
 #include "allocators.h"
 
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
-
 struct B
 {
     static bool constructed;
@@ -111,11 +111,8 @@ struct F
 
 bool F::constructed = false;
 
-#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
-
 int main()
 {
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
 
     {
         typedef std::scoped_allocator_adaptor<A1<std::string>> A;
@@ -188,6 +185,4 @@ int main()
         assert(A3<F>::constructed);
         s->~S();
     }
-
-#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 }
diff --git a/test/std/utilities/allocator.adaptor/allocator.adaptor.members/construct_pair.pass.cpp b/test/std/utilities/allocator.adaptor/allocator.adaptor.members/construct_pair.pass.cpp
new file mode 100644
index 000000000000..4e73d8064317
--- /dev/null
+++ b/test/std/utilities/allocator.adaptor/allocator.adaptor.members/construct_pair.pass.cpp
@@ -0,0 +1,139 @@
+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03
+
+// <scoped_allocator>
+
+// template <class OtherAlloc, class ...InnerAlloc>
+//   class scoped_allocator_adaptor
+
+// template <class U1, class U2>
+// void scoped_allocator_adaptor::construct(pair<U1, U2>*)
+
+#include <scoped_allocator>
+#include <type_traits>
+#include <utility>
+#include <tuple>
+#include <cassert>
+#include <cstdlib>
+#include "uses_alloc_types.hpp"
+#include "controlled_allocators.hpp"
+
+
+void test_no_inner_alloc()
+{
+    using VoidAlloc = CountingAllocator<void>;
+    AllocController P;
+    {
+        using T = UsesAllocatorV1<VoidAlloc, 0>;
+        using U = UsesAllocatorV2<VoidAlloc, 0>;
+        using Pair = std::pair<T, U>;
+        using Alloc = CountingAllocator<Pair>;
+        using SA = std::scoped_allocator_adaptor<Alloc>;
+        static_assert(std::uses_allocator<T, CountingAllocator<T> >::value, "");
+        Pair * ptr = (Pair*)std::malloc(sizeof(Pair));
+        Alloc CA(P);
+        SA A(CA);
+        A.construct(ptr);
+        assert(checkConstruct<>(ptr->first, UA_AllocArg, CA));
+        assert(checkConstruct<>(ptr->second, UA_AllocLast, CA));
+        assert((P.checkConstruct<std::piecewise_construct_t const&,
+                                 std::tuple<std::allocator_arg_t, SA&>&&,
+                                 std::tuple<SA&>&&
+              >(CA, ptr)));
+        A.destroy(ptr);
+        std::free(ptr);
+
+    }
+    P.reset();
+    {
+        using T = UsesAllocatorV3<VoidAlloc, 0>;
+        using U = NotUsesAllocator<VoidAlloc, 0>;
+        using Pair = std::pair<T, U>;
+        using Alloc = CountingAllocator<Pair>;
+        using SA = std::scoped_allocator_adaptor<Alloc>;
+        static_assert(std::uses_allocator<T, CountingAllocator<T> >::value, "");
+        Pair * ptr = (Pair*)std::malloc(sizeof(Pair));
+        Alloc CA(P);
+        SA A(CA);
+        A.construct(ptr);
+        assert(checkConstruct<>(ptr->first, UA_AllocArg, CA));
+        assert(checkConstruct<>(ptr->second, UA_None));
+        assert((P.checkConstruct<std::piecewise_construct_t const&,
+                                 std::tuple<std::allocator_arg_t, SA&>&&,
+                                 std::tuple<>&&
+                   >(CA, ptr)));
+        A.destroy(ptr);
+        std::free(ptr);
+    }
+}
+
+void test_with_inner_alloc()
+{
+    using VoidAlloc1 = CountingAllocator<void, 1>;
+    using VoidAlloc2 = CountingAllocator<void, 2>;
+
+    AllocController POuter;
+    AllocController PInner;
+    {
+        using T = UsesAllocatorV1<VoidAlloc2, 0>;
+        using U = UsesAllocatorV2<VoidAlloc2, 0>;
+        using Pair = std::pair<T, U>;
+        using Outer = CountingAllocator<Pair, 1>;
+        using Inner = CountingAllocator<Pair, 2>;
+        using SA = std::scoped_allocator_adaptor<Outer, Inner>;
+        using SAInner = std::scoped_allocator_adaptor<Inner>;
+        static_assert(!std::uses_allocator<T, Outer>::value, "");
+        static_assert(std::uses_allocator<T, Inner>::value, "");
+        Pair * ptr = (Pair*)std::malloc(sizeof(Pair));
+        Outer O(POuter);
+        Inner I(PInner);
+        SA A(O, I);
+        A.construct(ptr);
+        assert(checkConstruct<>(ptr->first, UA_AllocArg, I));
+        assert(checkConstruct<>(ptr->second, UA_AllocLast));
+        assert((POuter.checkConstruct<std::piecewise_construct_t const&,
+                                 std::tuple<std::allocator_arg_t, SAInner&>&&,
+                                 std::tuple<SAInner&>&&
+              >(O, ptr)));
+        A.destroy(ptr);
+        std::free(ptr);
+    }
+    PInner.reset();
+    POuter.reset();
+    {
+        using T = UsesAllocatorV3<VoidAlloc2, 0>;
+        using U = NotUsesAllocator<VoidAlloc2, 0>;
+        using Pair = std::pair<T, U>;
+        using Outer = CountingAllocator<Pair, 1>;
+        using Inner = CountingAllocator<Pair, 2>;
+        using SA = std::scoped_allocator_adaptor<Outer, Inner>;
+        using SAInner = std::scoped_allocator_adaptor<Inner>;
+        static_assert(!std::uses_allocator<T, Outer>::value, "");
+        static_assert(std::uses_allocator<T, Inner>::value, "");
+        Pair * ptr = (Pair*)std::malloc(sizeof(Pair));
+        Outer O(POuter);
+        Inner I(PInner);
+        SA A(O, I);
+        A.construct(ptr);
+        assert(checkConstruct<>(ptr->first, UA_AllocArg, I));
+        assert(checkConstruct<>(ptr->second, UA_None));
+        assert((POuter.checkConstruct<std::piecewise_construct_t const&,
+                                 std::tuple<std::allocator_arg_t, SAInner&>&&,
+                                 std::tuple<>&&
+              >(O, ptr)));
+        A.destroy(ptr);
+        std::free(ptr);
+    }
+}
+int main() {
+    test_no_inner_alloc();
+    test_with_inner_alloc();
+}
diff --git a/test/std/utilities/allocator.adaptor/allocator.adaptor.members/construct_pair_const_lvalue_pair.pass.cpp b/test/std/utilities/allocator.adaptor/allocator.adaptor.members/construct_pair_const_lvalue_pair.pass.cpp
new file mode 100644
index 000000000000..9effb6eded37
--- /dev/null
+++ b/test/std/utilities/allocator.adaptor/allocator.adaptor.members/construct_pair_const_lvalue_pair.pass.cpp
@@ -0,0 +1,155 @@
+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03
+
+// <scoped_allocator>
+
+// template <class OtherAlloc, class ...InnerAlloc>
+//   class scoped_allocator_adaptor
+
+// template <class U1, class U2>
+// void scoped_allocator_adaptor::construct(pair<U1, U2>*, pair<T1, T2>const&)
+
+#include <scoped_allocator>
+#include <type_traits>
+#include <utility>
+#include <tuple>
+#include <cassert>
+#include <cstdlib>
+#include "uses_alloc_types.hpp"
+#include "controlled_allocators.hpp"
+
+
+void test_no_inner_alloc()
+{
+    using VoidAlloc = CountingAllocator<void>;
+    AllocController P;
+    {
+        using T = UsesAllocatorV1<VoidAlloc, 1>;
+        using U = UsesAllocatorV2<VoidAlloc, 1>;
+        using Pair = std::pair<T, U>;
+        using PairIn = std::pair<int&, int const&&>;
+        int x = 42;
+        const int y = 101;
+        using Alloc = CountingAllocator<Pair>;
+        using SA = std::scoped_allocator_adaptor<Alloc>;
+        static_assert(std::uses_allocator<T, CountingAllocator<T> >::value, "");
+        Pair * ptr = (Pair*)std::malloc(sizeof(Pair));
+        Alloc CA(P);
+        SA A(CA);
+        const PairIn in(x, std::move(y));
+        A.construct(ptr, in);
+        assert(checkConstruct<int&>(ptr->first, UA_AllocArg, CA));
+        assert(checkConstruct<int const&>(ptr->second, UA_AllocLast, CA));
+        assert((P.checkConstruct<std::piecewise_construct_t const&,
+                                 std::tuple<std::allocator_arg_t, SA&, int&>&&,
+                                 std::tuple<int const&, SA&>&&
+              >(CA, ptr)));
+        A.destroy(ptr);
+        std::free(ptr);
+
+    }
+    P.reset();
+    {
+        using T = UsesAllocatorV3<VoidAlloc, 1>;
+        using U = NotUsesAllocator<VoidAlloc, 1>;
+        using Pair = std::pair<T, U>;
+        using PairIn = std::pair<int, int const&>;
+        int x = 42;
+        const int y = 101;
+        using Alloc = CountingAllocator<Pair>;
+        using SA = std::scoped_allocator_adaptor<Alloc>;
+        static_assert(std::uses_allocator<T, CountingAllocator<T> >::value, "");
+        Pair * ptr = (Pair*)std::malloc(sizeof(Pair));
+        Alloc CA(P);
+        SA A(CA);
+        const PairIn in(x, y);
+        A.construct(ptr, in);
+        assert(checkConstruct<int const&>(ptr->first, UA_AllocArg, CA));
+        assert(checkConstruct<int const&>(ptr->second, UA_None));
+        assert((P.checkConstruct<std::piecewise_construct_t const&,
+                                 std::tuple<std::allocator_arg_t, SA&, int const&>&&,
+                                 std::tuple<int const&>&&
+                   >(CA, ptr)));
+        A.destroy(ptr);
+        std::free(ptr);
+    }
+}
+
+void test_with_inner_alloc()
+{
+    using VoidAlloc1 = CountingAllocator<void, 1>;
+    using VoidAlloc2 = CountingAllocator<void, 2>;
+
+    AllocController POuter;
+    AllocController PInner;
+    {
+        using T = UsesAllocatorV1<VoidAlloc2, 1>;
+        using U = UsesAllocatorV2<VoidAlloc2, 1>;
+        using Pair = std::pair<T, U>;
+        using PairIn = std::pair<int&, int const&&>;
+        int x = 42;
+        int y = 101;
+        using Outer = CountingAllocator<Pair, 1>;
+        using Inner = CountingAllocator<Pair, 2>;
+        using SA = std::scoped_allocator_adaptor<Outer, Inner>;
+        using SAInner = std::scoped_allocator_adaptor<Inner>;
+        static_assert(!std::uses_allocator<T, Outer>::value, "");
+        static_assert(std::uses_allocator<T, Inner>::value, "");
+        Pair * ptr = (Pair*)std::malloc(sizeof(Pair));
+        Outer O(POuter);
+        Inner I(PInner);
+        SA A(O, I);
+        const PairIn in(x, std::move(y));
+        A.construct(ptr, in);
+        assert(checkConstruct<int&>(ptr->first, UA_AllocArg, I));
+        assert(checkConstruct<int const&>(ptr->second, UA_AllocLast));
+        assert((POuter.checkConstruct<std::piecewise_construct_t const&,
+                                 std::tuple<std::allocator_arg_t, SAInner&, int&>&&,
+                                 std::tuple<int const&, SAInner&>&&
+              >(O, ptr)));
+        A.destroy(ptr);
+        std::free(ptr);
+    }
+    PInner.reset();
+    POuter.reset();
+    {
+        using T = UsesAllocatorV3<VoidAlloc2, 1>;
+        using U = NotUsesAllocator<VoidAlloc2, 1>;
+        using Pair = std::pair<T, U>;
+        using PairIn = std::pair<int, int const &>;
+        int x = 42;
+        int y = 101;
+        using Outer = CountingAllocator<Pair, 1>;
+        using Inner = CountingAllocator<Pair, 2>;
+        using SA = std::scoped_allocator_adaptor<Outer, Inner>;
+        using SAInner = std::scoped_allocator_adaptor<Inner>;
+        static_assert(!std::uses_allocator<T, Outer>::value, "");
+        static_assert(std::uses_allocator<T, Inner>::value, "");
+        Pair * ptr = (Pair*)std::malloc(sizeof(Pair));
+        Outer O(POuter);
+        Inner I(PInner);
+        SA A(O, I);
+        const PairIn in(x, y);
+        A.construct(ptr, in);
+        assert(checkConstruct<int const&>(ptr->first, UA_AllocArg, I));
+        assert(checkConstruct<int const&>(ptr->second, UA_None));
+        assert((POuter.checkConstruct<std::piecewise_construct_t const&,
+                                 std::tuple<std::allocator_arg_t, SAInner&, int const&>&&,
+                                 std::tuple<int const&>&&
+              >(O, ptr)));
+        A.destroy(ptr);
+        std::free(ptr);
+    }
+}
+int main() {
+    test_no_inner_alloc();
+    test_with_inner_alloc();
+}
diff --git a/test/std/utilities/allocator.adaptor/allocator.adaptor.members/construct_pair_piecewise.pass.cpp b/test/std/utilities/allocator.adaptor/allocator.adaptor.members/construct_pair_piecewise.pass.cpp
new file mode 100644
index 000000000000..4d371f206e65
--- /dev/null
+++ b/test/std/utilities/allocator.adaptor/allocator.adaptor.members/construct_pair_piecewise.pass.cpp
@@ -0,0 +1,156 @@
+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03
+
+// <scoped_allocator>
+
+// template <class OtherAlloc, class ...InnerAlloc>
+//   class scoped_allocator_adaptor
+
+// template <class U1, class U2, class ...Args1, class ...Args2>
+// void scoped_allocator_adaptor::construct(pair<U1, U2>*,
+//     piecewise_construct_t, tuple<Args1...>, tuple<Args2...>)
+
+#include <scoped_allocator>
+#include <type_traits>
+#include <utility>
+#include <tuple>
+#include <cassert>
+#include <cstdlib>
+#include "uses_alloc_types.hpp"
+#include "controlled_allocators.hpp"
+
+
+void test_no_inner_alloc()
+{
+    using VoidAlloc = CountingAllocator<void>;
+    AllocController P;
+    {
+        using T = UsesAllocatorV1<VoidAlloc, 1>;
+        using U = UsesAllocatorV2<VoidAlloc, 1>;
+        using Pair = std::pair<T, U>;
+        int x = 42;
+        const int y = 101;
+        using Alloc = CountingAllocator<Pair>;
+        using SA = std::scoped_allocator_adaptor<Alloc>;
+        static_assert(std::uses_allocator<T, CountingAllocator<T> >::value, "");
+        Pair * ptr = (Pair*)std::malloc(sizeof(Pair));
+        Alloc CA(P);
+        SA A(CA);
+        A.construct(ptr, std::piecewise_construct,
+                    std::forward_as_tuple(x),
+                    std::forward_as_tuple(std::move(y)));
+        assert(checkConstruct<int&>(ptr->first, UA_AllocArg, CA));
+        assert(checkConstruct<int const&&>(ptr->second, UA_AllocLast, CA));
+        assert((P.checkConstruct<std::piecewise_construct_t const&,
+                                 std::tuple<std::allocator_arg_t, SA&, int&>&&,
+                                 std::tuple<int const&&, SA&>&&
+              >(CA, ptr)));
+        A.destroy(ptr);
+        std::free(ptr);
+
+    }
+    P.reset();
+    {
+        using T = UsesAllocatorV3<VoidAlloc, 1>;
+        using U = NotUsesAllocator<VoidAlloc, 1>;
+        using Pair = std::pair<T, U>;
+        int x = 42;
+        const int y = 101;
+        using Alloc = CountingAllocator<Pair>;
+        using SA = std::scoped_allocator_adaptor<Alloc>;
+        static_assert(std::uses_allocator<T, CountingAllocator<T> >::value, "");
+        Pair * ptr = (Pair*)std::malloc(sizeof(Pair));
+        Alloc CA(P);
+        SA A(CA);
+        A.construct(ptr, std::piecewise_construct,
+                    std::forward_as_tuple(std::move(x)),
+                    std::forward_as_tuple(y));
+        assert(checkConstruct<int&&>(ptr->first, UA_AllocArg, CA));
+        assert(checkConstruct<int const&>(ptr->second, UA_None));
+        assert((P.checkConstruct<std::piecewise_construct_t const&,
+                                 std::tuple<std::allocator_arg_t, SA&, int&&>&&,
+                                 std::tuple<int const&>&&
+                   >(CA, ptr)));
+        A.destroy(ptr);
+        std::free(ptr);
+    }
+}
+
+void test_with_inner_alloc()
+{
+    using VoidAlloc1 = CountingAllocator<void, 1>;
+    using VoidAlloc2 = CountingAllocator<void, 2>;
+
+    AllocController POuter;
+    AllocController PInner;
+    {
+        using T = UsesAllocatorV1<VoidAlloc2, 1>;
+        using U = UsesAllocatorV2<VoidAlloc2, 1>;
+        using Pair = std::pair<T, U>;
+        int x = 42;
+        int y = 101;
+        using Outer = CountingAllocator<Pair, 1>;
+        using Inner = CountingAllocator<Pair, 2>;
+        using SA = std::scoped_allocator_adaptor<Outer, Inner>;
+        using SAInner = std::scoped_allocator_adaptor<Inner>;
+        static_assert(!std::uses_allocator<T, Outer>::value, "");
+        static_assert(std::uses_allocator<T, Inner>::value, "");
+        Pair * ptr = (Pair*)std::malloc(sizeof(Pair));
+        Outer O(POuter);
+        Inner I(PInner);
+        SA A(O, I);
+        A.construct(ptr, std::piecewise_construct,
+                    std::forward_as_tuple(x),
+                    std::forward_as_tuple(std::move(y)));
+        assert(checkConstruct<int&>(ptr->first, UA_AllocArg, I));
+        assert(checkConstruct<int &&>(ptr->second, UA_AllocLast));
+        assert((POuter.checkConstruct<std::piecewise_construct_t const&,
+                                 std::tuple<std::allocator_arg_t, SAInner&, int&>&&,
+                                 std::tuple<int &&, SAInner&>&&
+              >(O, ptr)));
+        A.destroy(ptr);
+        std::free(ptr);
+    }
+    PInner.reset();
+    POuter.reset();
+    {
+        using T = UsesAllocatorV3<VoidAlloc2, 1>;
+        using U = NotUsesAllocator<VoidAlloc2, 1>;
+        using Pair = std::pair<T, U>;
+        int x = 42;
+        const int y = 101;
+        using Outer = CountingAllocator<Pair, 1>;
+        using Inner = CountingAllocator<Pair, 2>;
+        using SA = std::scoped_allocator_adaptor<Outer, Inner>;
+        using SAInner = std::scoped_allocator_adaptor<Inner>;
+        static_assert(!std::uses_allocator<T, Outer>::value, "");
+        static_assert(std::uses_allocator<T, Inner>::value, "");
+        Pair * ptr = (Pair*)std::malloc(sizeof(Pair));
+        Outer O(POuter);
+        Inner I(PInner);
+        SA A(O, I);
+        A.construct(ptr, std::piecewise_construct,
+                    std::forward_as_tuple(std::move(x)),
+                    std::forward_as_tuple(std::move(y)));
+        assert(checkConstruct<int&&>(ptr->first, UA_AllocArg, I));
+        assert(checkConstruct<int const&&>(ptr->second, UA_None));
+        assert((POuter.checkConstruct<std::piecewise_construct_t const&,
+                                 std::tuple<std::allocator_arg_t, SAInner&, int&&>&&,
+                                 std::tuple<int const&&>&&
+              >(O, ptr)));
+        A.destroy(ptr);
+        std::free(ptr);
+    }
+}
+int main() {
+    test_no_inner_alloc();
+    test_with_inner_alloc();
+}
diff --git a/test/std/utilities/allocator.adaptor/allocator.adaptor.members/construct_pair_rvalue.pass.cpp b/test/std/utilities/allocator.adaptor/allocator.adaptor.members/construct_pair_rvalue.pass.cpp
new file mode 100644
index 000000000000..1d0fb5157c02
--- /dev/null
+++ b/test/std/utilities/allocator.adaptor/allocator.adaptor.members/construct_pair_rvalue.pass.cpp
@@ -0,0 +1,155 @@
+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03
+
+// <scoped_allocator>
+
+// template <class OtherAlloc, class ...InnerAlloc>
+//   class scoped_allocator_adaptor
+
+// template <class U1, class U2>
+// void scoped_allocator_adaptor::construct(pair<U1, U2>*, pair<T1, T2>&&)
+
+#include <scoped_allocator>
+#include <type_traits>
+#include <utility>
+#include <tuple>
+#include <cassert>
+#include <cstdlib>
+#include "uses_alloc_types.hpp"
+#include "controlled_allocators.hpp"
+
+
+void test_no_inner_alloc()
+{
+    using VoidAlloc = CountingAllocator<void>;
+    AllocController P;
+    {
+        using T = UsesAllocatorV1<VoidAlloc, 1>;
+        using U = UsesAllocatorV2<VoidAlloc, 1>;
+        using Pair = std::pair<T, U>;
+        using PairIn = std::pair<int&, int const&&>;
+        int x = 42;
+        const int y = 101;
+        using Alloc = CountingAllocator<Pair>;
+        using SA = std::scoped_allocator_adaptor<Alloc>;
+        static_assert(std::uses_allocator<T, CountingAllocator<T> >::value, "");
+        Pair * ptr = (Pair*)std::malloc(sizeof(Pair));
+        Alloc CA(P);
+        SA A(CA);
+        PairIn in(x, std::move(y));
+        A.construct(ptr, std::move(in));
+        assert(checkConstruct<int&>(ptr->first, UA_AllocArg, CA));
+        assert(checkConstruct<int const&&>(ptr->second, UA_AllocLast, CA));
+        assert((P.checkConstruct<std::piecewise_construct_t const&,
+                                 std::tuple<std::allocator_arg_t, SA&, int&>&&,
+                                 std::tuple<int const&&, SA&>&&
+              >(CA, ptr)));
+        A.destroy(ptr);
+        std::free(ptr);
+
+    }
+    P.reset();
+    {
+        using T = UsesAllocatorV3<VoidAlloc, 1>;
+        using U = NotUsesAllocator<VoidAlloc, 1>;
+        using Pair = std::pair<T, U>;
+        using PairIn = std::pair<int, int const&>;
+        int x = 42;
+        const int y = 101;
+        using Alloc = CountingAllocator<Pair>;
+        using SA = std::scoped_allocator_adaptor<Alloc>;
+        static_assert(std::uses_allocator<T, CountingAllocator<T> >::value, "");
+        Pair * ptr = (Pair*)std::malloc(sizeof(Pair));
+        Alloc CA(P);
+        SA A(CA);
+        PairIn in(x, y);
+        A.construct(ptr, std::move(in));
+        assert(checkConstruct<int&&>(ptr->first, UA_AllocArg, CA));
+        assert(checkConstruct<int const&>(ptr->second, UA_None));
+        assert((P.checkConstruct<std::piecewise_construct_t const&,
+                                 std::tuple<std::allocator_arg_t, SA&, int&&>&&,
+                                 std::tuple<int const&>&&
+                   >(CA, ptr)));
+        A.destroy(ptr);
+        std::free(ptr);
+    }
+}
+
+void test_with_inner_alloc()
+{
+    using VoidAlloc1 = CountingAllocator<void, 1>;
+    using VoidAlloc2 = CountingAllocator<void, 2>;
+
+    AllocController POuter;
+    AllocController PInner;
+    {
+        using T = UsesAllocatorV1<VoidAlloc2, 1>;
+        using U = UsesAllocatorV2<VoidAlloc2, 1>;
+        using Pair = std::pair<T, U>;
+        using PairIn = std::pair<int&, int const&&>;
+        int x = 42;
+        int y = 101;
+        using Outer = CountingAllocator<Pair, 1>;
+        using Inner = CountingAllocator<Pair, 2>;
+        using SA = std::scoped_allocator_adaptor<Outer, Inner>;
+        using SAInner = std::scoped_allocator_adaptor<Inner>;
+        static_assert(!std::uses_allocator<T, Outer>::value, "");
+        static_assert(std::uses_allocator<T, Inner>::value, "");
+        Pair * ptr = (Pair*)std::malloc(sizeof(Pair));
+        Outer O(POuter);
+        Inner I(PInner);
+        SA A(O, I);
+        PairIn in(x, std::move(y));
+        A.construct(ptr, std::move(in));
+        assert(checkConstruct<int&>(ptr->first, UA_AllocArg, I));
+        assert(checkConstruct<int const&&>(ptr->second, UA_AllocLast));
+        assert((POuter.checkConstruct<std::piecewise_construct_t const&,
+                                 std::tuple<std::allocator_arg_t, SAInner&, int&>&&,
+                                 std::tuple<int const&&, SAInner&>&&
+              >(O, ptr)));
+        A.destroy(ptr);
+        std::free(ptr);
+    }
+    PInner.reset();
+    POuter.reset();
+    {
+        using T = UsesAllocatorV3<VoidAlloc2, 1>;
+        using U = NotUsesAllocator<VoidAlloc2, 1>;
+        using Pair = std::pair<T, U>;
+        using PairIn = std::pair<int, int const &>;
+        int x = 42;
+        int y = 101;
+        using Outer = CountingAllocator<Pair, 1>;
+        using Inner = CountingAllocator<Pair, 2>;
+        using SA = std::scoped_allocator_adaptor<Outer, Inner>;
+        using SAInner = std::scoped_allocator_adaptor<Inner>;
+        static_assert(!std::uses_allocator<T, Outer>::value, "");
+        static_assert(std::uses_allocator<T, Inner>::value, "");
+        Pair * ptr = (Pair*)std::malloc(sizeof(Pair));
+        Outer O(POuter);
+        Inner I(PInner);
+        SA A(O, I);
+        PairIn in(x, y);
+        A.construct(ptr, std::move(in));
+        assert(checkConstruct<int&&>(ptr->first, UA_AllocArg, I));
+        assert(checkConstruct<int const&>(ptr->second, UA_None));
+        assert((POuter.checkConstruct<std::piecewise_construct_t const&,
+                                 std::tuple<std::allocator_arg_t, SAInner&, int&&>&&,
+                                 std::tuple<int const&>&&
+              >(O, ptr)));
+        A.destroy(ptr);
+        std::free(ptr);
+    }
+}
+int main() {
+    test_no_inner_alloc();
+    test_with_inner_alloc();
+}
diff --git a/test/std/utilities/allocator.adaptor/allocator.adaptor.members/construct_pair_values.pass.cpp b/test/std/utilities/allocator.adaptor/allocator.adaptor.members/construct_pair_values.pass.cpp
new file mode 100644
index 000000000000..840f4ecc616d
--- /dev/null
+++ b/test/std/utilities/allocator.adaptor/allocator.adaptor.members/construct_pair_values.pass.cpp
@@ -0,0 +1,147 @@
+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03
+
+// <scoped_allocator>
+
+// template <class OtherAlloc, class ...InnerAlloc>
+//   class scoped_allocator_adaptor
+
+// template <class U1, class U2, class Tp, class Vp>
+// void scoped_allocator_adaptor::construct(pair<U1, U2>*, Tp&&, Up&&)
+
+#include <scoped_allocator>
+#include <type_traits>
+#include <utility>
+#include <tuple>
+#include <cassert>
+#include <cstdlib>
+#include "uses_alloc_types.hpp"
+#include "controlled_allocators.hpp"
+
+
+void test_no_inner_alloc()
+{
+    using VoidAlloc = CountingAllocator<void>;
+    AllocController P;
+    {
+        using T = UsesAllocatorV1<VoidAlloc, 1>;
+        using U = UsesAllocatorV2<VoidAlloc, 1>;
+        using Pair = std::pair<T, U>;
+        int x = 42;
+        const int y = 101;
+        using Alloc = CountingAllocator<Pair>;
+        using SA = std::scoped_allocator_adaptor<Alloc>;
+        static_assert(std::uses_allocator<T, CountingAllocator<T> >::value, "");
+        Pair * ptr = (Pair*)std::malloc(sizeof(Pair));
+        Alloc CA(P);
+        SA A(CA);
+        A.construct(ptr, x, std::move(y));
+        assert(checkConstruct<int&>(ptr->first, UA_AllocArg, CA));
+        assert(checkConstruct<int const&&>(ptr->second, UA_AllocLast, CA));
+        assert((P.checkConstruct<std::piecewise_construct_t const&,
+                                 std::tuple<std::allocator_arg_t, SA&, int&>&&,
+                                 std::tuple<int const&&, SA&>&&
+              >(CA, ptr)));
+        A.destroy(ptr);
+        std::free(ptr);
+
+    }
+    P.reset();
+    {
+        using T = UsesAllocatorV3<VoidAlloc, 1>;
+        using U = NotUsesAllocator<VoidAlloc, 1>;
+        using Pair = std::pair<T, U>;
+        int x = 42;
+        const int y = 101;
+        using Alloc = CountingAllocator<Pair>;
+        using SA = std::scoped_allocator_adaptor<Alloc>;
+        static_assert(std::uses_allocator<T, CountingAllocator<T> >::value, "");
+        Pair * ptr = (Pair*)std::malloc(sizeof(Pair));
+        Alloc CA(P);
+        SA A(CA);
+        A.construct(ptr, std::move(x), y);
+        assert(checkConstruct<int&&>(ptr->first, UA_AllocArg, CA));
+        assert(checkConstruct<int const&>(ptr->second, UA_None));
+        assert((P.checkConstruct<std::piecewise_construct_t const&,
+                                 std::tuple<std::allocator_arg_t, SA&, int&&>&&,
+                                 std::tuple<int const&>&&
+                   >(CA, ptr)));
+        A.destroy(ptr);
+        std::free(ptr);
+    }
+}
+
+void test_with_inner_alloc()
+{
+    using VoidAlloc1 = CountingAllocator<void, 1>;
+    using VoidAlloc2 = CountingAllocator<void, 2>;
+
+    AllocController POuter;
+    AllocController PInner;
+    {
+        using T = UsesAllocatorV1<VoidAlloc2, 1>;
+        using U = UsesAllocatorV2<VoidAlloc2, 1>;
+        using Pair = std::pair<T, U>;
+        int x = 42;
+        int y = 101;
+        using Outer = CountingAllocator<Pair, 1>;
+        using Inner = CountingAllocator<Pair, 2>;
+        using SA = std::scoped_allocator_adaptor<Outer, Inner>;
+        using SAInner = std::scoped_allocator_adaptor<Inner>;
+        static_assert(!std::uses_allocator<T, Outer>::value, "");
+        static_assert(std::uses_allocator<T, Inner>::value, "");
+        Pair * ptr = (Pair*)std::malloc(sizeof(Pair));
+        Outer O(POuter);
+        Inner I(PInner);
+        SA A(O, I);
+        A.construct(ptr, x, std::move(y));
+        assert(checkConstruct<int&>(ptr->first, UA_AllocArg, I));
+        assert(checkConstruct<int &&>(ptr->second, UA_AllocLast));
+        assert((POuter.checkConstruct<std::piecewise_construct_t const&,
+                                 std::tuple<std::allocator_arg_t, SAInner&, int&>&&,
+                                 std::tuple<int &&, SAInner&>&&
+              >(O, ptr)));
+        A.destroy(ptr);
+        std::free(ptr);
+    }
+    PInner.reset();
+    POuter.reset();
+    {
+        using T = UsesAllocatorV3<VoidAlloc2, 1>;
+        using U = NotUsesAllocator<VoidAlloc2, 1>;
+        using Pair = std::pair<T, U>;
+        int x = 42;
+        const int y = 101;
+        using Outer = CountingAllocator<Pair, 1>;
+        using Inner = CountingAllocator<Pair, 2>;
+        using SA = std::scoped_allocator_adaptor<Outer, Inner>;
+        using SAInner = std::scoped_allocator_adaptor<Inner>;
+        static_assert(!std::uses_allocator<T, Outer>::value, "");
+        static_assert(std::uses_allocator<T, Inner>::value, "");
+        Pair * ptr = (Pair*)std::malloc(sizeof(Pair));
+        Outer O(POuter);
+        Inner I(PInner);
+        SA A(O, I);
+        A.construct(ptr, std::move(x), std::move(y));
+        assert(checkConstruct<int&&>(ptr->first, UA_AllocArg, I));
+        assert(checkConstruct<int const&&>(ptr->second, UA_None));
+        assert((POuter.checkConstruct<std::piecewise_construct_t const&,
+                                 std::tuple<std::allocator_arg_t, SAInner&, int&&>&&,
+                                 std::tuple<int const&&>&&
+              >(O, ptr)));
+        A.destroy(ptr);
+        std::free(ptr);
+    }
+}
+int main() {
+    test_no_inner_alloc();
+    test_with_inner_alloc();
+}
diff --git a/test/std/utilities/allocator.adaptor/allocator.adaptor.members/construct_type.pass.cpp b/test/std/utilities/allocator.adaptor/allocator.adaptor.members/construct_type.pass.cpp
new file mode 100644
index 000000000000..867cc74082e7
--- /dev/null
+++ b/test/std/utilities/allocator.adaptor/allocator.adaptor.members/construct_type.pass.cpp
@@ -0,0 +1,139 @@
+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03
+
+// <scoped_allocator>
+
+// template <class OtherAlloc, class ...InnerAlloc>
+//   class scoped_allocator_adaptor
+
+// template <class T, class ...Args>
+// void scoped_allocator_adaptor::construct(T*, Args&&...)
+
+#include <scoped_allocator>
+#include <type_traits>
+#include <utility>
+#include <tuple>
+#include <cassert>
+#include <cstdlib>
+#include "uses_alloc_types.hpp"
+#include "controlled_allocators.hpp"
+
+// — If uses_allocator_v<T, inner_allocator_type> is false and
+//   is_constructible_v<T, Args...> is true, calls
+//   OUTERMOST_ALLOC_TRAITS(*this)::construct(
+//      OUTERMOST (*this), p, std::forward<Args>(args)...).
+void test_bullet_one() {
+    using VoidAlloc1 = CountingAllocator<void, 1>;
+    using VoidAlloc2 = CountingAllocator<void, 2>;
+
+    AllocController POuter;
+    AllocController PInner;
+    {
+        using T = NotUsesAllocator<VoidAlloc2, 3>;
+        using Outer = CountingAllocator<T, 1>;
+        using Inner = CountingAllocator<T, 2>;
+        using SA = std::scoped_allocator_adaptor<Outer, Inner>;
+        using SAInner = std::scoped_allocator_adaptor<Inner>;
+        static_assert(!std::uses_allocator<T, Outer>::value, "");
+        static_assert(!std::uses_allocator<T, Inner>::value, "");
+        T* ptr = (T*)::operator new(sizeof(T));
+        Outer O(POuter);
+        Inner I(PInner);
+        SA A(O, I);
+        int x = 42;
+        int const& cx = x;
+        A.construct(ptr, x, cx, std::move(x));
+        assert((checkConstruct<int&, int const&, int&&>(*ptr, UA_None)));
+        assert((POuter.checkConstruct<int&, int const&, int&&>(O, ptr)));
+        A.destroy(ptr);
+        ::operator delete((void*)ptr);
+    }
+    PInner.reset();
+    POuter.reset();
+}
+
+
+// Otherwise, if uses_allocator_v<T, inner_allocator_type> is true and
+// is_constructible_v<T, allocator_arg_t, inner_allocator_type&, Args...> is
+// true, calls OUTERMOST_ALLOC_TRAITS(*this)::construct(OUTERMOST (*this), p,
+//     allocator_arg, inner_allocator(), std::forward<Args>(args)...).
+void test_bullet_two() {
+    using VoidAlloc1 = CountingAllocator<void, 1>;
+    using VoidAlloc2 = CountingAllocator<void, 2>;
+
+    AllocController POuter;
+    AllocController PInner;
+    {
+        using T = UsesAllocatorV1<VoidAlloc2, 3>;
+        using Outer = CountingAllocator<T, 1>;
+        using Inner = CountingAllocator<T, 2>;
+        using SA = std::scoped_allocator_adaptor<Outer, Inner>;
+        using SAInner = std::scoped_allocator_adaptor<Inner>;
+        static_assert(!std::uses_allocator<T, Outer>::value, "");
+        static_assert(std::uses_allocator<T, Inner>::value, "");
+        T* ptr = (T*)::operator new(sizeof(T));
+        Outer O(POuter);
+        Inner I(PInner);
+        SA A(O, I);
+        int x = 42;
+        int const& cx = x;
+        A.construct(ptr, x, cx, std::move(x));
+        assert((checkConstruct<int&, int const&, int&&>(*ptr, UA_AllocArg, I)));
+        assert((POuter.checkConstruct<std::allocator_arg_t const&,
+                   SA::inner_allocator_type&, int&, int const&, int&&>(O, ptr)));
+        A.destroy(ptr);
+        ::operator delete((void*)ptr);
+    }
+    PInner.reset();
+    POuter.reset();
+}
+
+// Otherwise, if uses_allocator_v<T, inner_allocator_type> is true and
+// is_constructible_v<T, Args..., inner_allocator_type&> is true, calls
+// OUTERMOST_ALLOC_TRAITS(*this)::construct(OUTERMOST (*this), p,
+//   std::forward<Args>(args)..., inner_allocator()).
+void test_bullet_three() {
+    using VoidAlloc1 = CountingAllocator<void, 1>;
+    using VoidAlloc2 = CountingAllocator<void, 2>;
+
+    AllocController POuter;
+    AllocController PInner;
+    {
+        using T = UsesAllocatorV2<VoidAlloc2, 3>;
+        using Outer = CountingAllocator<T, 1>;
+        using Inner = CountingAllocator<T, 2>;
+        using SA = std::scoped_allocator_adaptor<Outer, Inner>;
+        using SAInner = std::scoped_allocator_adaptor<Inner>;
+        static_assert(!std::uses_allocator<T, Outer>::value, "");
+        static_assert(std::uses_allocator<T, Inner>::value, "");
+        T* ptr = (T*)::operator new(sizeof(T));
+        Outer O(POuter);
+        Inner I(PInner);
+        SA A(O, I);
+        int x = 42;
+        int const& cx = x;
+        A.construct(ptr, x, cx, std::move(x));
+        assert((checkConstruct<int&, int const&, int&&>(*ptr, UA_AllocLast, I)));
+        assert((POuter.checkConstruct<
+                   int&, int const&, int&&,
+                   SA::inner_allocator_type&>(O, ptr)));
+        A.destroy(ptr);
+        ::operator delete((void*)ptr);
+    }
+    PInner.reset();
+    POuter.reset();
+}
+
+int main() {
+    test_bullet_one();
+    test_bullet_two();
+    test_bullet_three();
+}
diff --git a/test/std/utilities/allocator.adaptor/allocator.adaptor.members/deallocate.pass.cpp b/test/std/utilities/allocator.adaptor/allocator.adaptor.members/deallocate.pass.cpp
index bf77f29f7145..7924140cf2cd 100644
--- a/test/std/utilities/allocator.adaptor/allocator.adaptor.members/deallocate.pass.cpp
+++ b/test/std/utilities/allocator.adaptor/allocator.adaptor.members/deallocate.pass.cpp
@@ -7,6 +7,8 @@
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: c++98, c++03
+
 // <memory>
 
 // template <class OuterAlloc, class... InnerAllocs>
@@ -21,7 +23,6 @@
 
 int main()
 {
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
 
     {
         typedef std::scoped_allocator_adaptor<A1<int>> A;
@@ -42,5 +43,4 @@ int main()
         assert((A1<int>::deallocate_called == std::pair<int*, std::size_t>((int*)10, 20)));
     }
 
-#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 }
diff --git a/test/std/utilities/allocator.adaptor/allocator.adaptor.members/destroy.pass.cpp b/test/std/utilities/allocator.adaptor/allocator.adaptor.members/destroy.pass.cpp
index 0ff3880f9fc1..96850d783b99 100644
--- a/test/std/utilities/allocator.adaptor/allocator.adaptor.members/destroy.pass.cpp
+++ b/test/std/utilities/allocator.adaptor/allocator.adaptor.members/destroy.pass.cpp
@@ -7,6 +7,8 @@
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: c++98, c++03
+
 // <memory>
 
 // template <class OuterAlloc, class... InnerAllocs>
@@ -32,8 +34,6 @@ bool B::constructed = false;
 
 int main()
 {
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
-
     {
         typedef std::scoped_allocator_adaptor<A1<B>> A;
         A a;
@@ -66,5 +66,4 @@ int main()
         assert(A3<S>::destroy_called);
     }
 
-#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 }
diff --git a/test/std/utilities/allocator.adaptor/allocator.adaptor.members/inner_allocator.pass.cpp b/test/std/utilities/allocator.adaptor/allocator.adaptor.members/inner_allocator.pass.cpp
index 0fb55b692cdb..9b892abd81f3 100644
--- a/test/std/utilities/allocator.adaptor/allocator.adaptor.members/inner_allocator.pass.cpp
+++ b/test/std/utilities/allocator.adaptor/allocator.adaptor.members/inner_allocator.pass.cpp
@@ -7,6 +7,8 @@
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: c++98, c++03
+
 // <memory>
 
 // template <class OuterAlloc, class... InnerAllocs>
@@ -22,8 +24,6 @@
 
 int main()
 {
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
-
     {
         typedef std::scoped_allocator_adaptor<A1<int>> A;
         A a(A1<int>(5));
@@ -41,5 +41,4 @@ int main()
             std::scoped_allocator_adaptor<A2<int>, A3<int>>(A2<int>(6), A3<int>(8))));
     }
 
-#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 }
diff --git a/test/std/utilities/allocator.adaptor/allocator.adaptor.members/max_size.pass.cpp b/test/std/utilities/allocator.adaptor/allocator.adaptor.members/max_size.pass.cpp
index a5275ee30253..8b88dcc963dd 100644
--- a/test/std/utilities/allocator.adaptor/allocator.adaptor.members/max_size.pass.cpp
+++ b/test/std/utilities/allocator.adaptor/allocator.adaptor.members/max_size.pass.cpp
@@ -7,6 +7,8 @@
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: c++98, c++03
+
 // <memory>
 
 // template <class OuterAlloc, class... InnerAllocs>
@@ -21,8 +23,6 @@
 
 int main()
 {
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
-
     {
         typedef std::scoped_allocator_adaptor<A1<int>> A;
         const A a(A1<int>(100));
@@ -39,5 +39,4 @@ int main()
         assert(a.max_size() == 200);
     }
 
-#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 }
diff --git a/test/std/utilities/allocator.adaptor/allocator.adaptor.members/outer_allocator.pass.cpp b/test/std/utilities/allocator.adaptor/allocator.adaptor.members/outer_allocator.pass.cpp
index 2297612e6098..238d46017b0a 100644
--- a/test/std/utilities/allocator.adaptor/allocator.adaptor.members/outer_allocator.pass.cpp
+++ b/test/std/utilities/allocator.adaptor/allocator.adaptor.members/outer_allocator.pass.cpp
@@ -7,6 +7,8 @@
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: c++98, c++03
+
 // <memory>
 
 // template <class OuterAlloc, class... InnerAllocs>
@@ -22,7 +24,6 @@
 
 int main()
 {
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
 
     {
         typedef std::scoped_allocator_adaptor<A1<int>> A;
@@ -39,6 +40,4 @@ int main()
         A a(A1<int>(5), A2<int>(6), A3<int>(8));
         assert(a.outer_allocator() == A1<int>(5));
     }
-
-#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 }
diff --git a/test/std/utilities/allocator.adaptor/allocator.adaptor.members/select_on_container_copy_construction.pass.cpp b/test/std/utilities/allocator.adaptor/allocator.adaptor.members/select_on_container_copy_construction.pass.cpp
index f9f0ffa2ad2a..8ee048bb99f1 100644
--- a/test/std/utilities/allocator.adaptor/allocator.adaptor.members/select_on_container_copy_construction.pass.cpp
+++ b/test/std/utilities/allocator.adaptor/allocator.adaptor.members/select_on_container_copy_construction.pass.cpp
@@ -7,6 +7,8 @@
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: c++98, c++03
+
 // <memory>
 
 // template <class OuterAlloc, class... InnerAllocs>
@@ -21,8 +23,6 @@
 
 int main()
 {
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
-
     {
         typedef std::scoped_allocator_adaptor<A1<int>> A;
         A a1(A1<int>(3));
@@ -51,5 +51,4 @@ int main()
         assert(a2.inner_allocator().inner_allocator().outer_allocator().id() == -1);
     }
 
-#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 }
diff --git a/test/std/utilities/allocator.adaptor/allocator.adaptor.types/inner_allocator_type.pass.cpp b/test/std/utilities/allocator.adaptor/allocator.adaptor.types/inner_allocator_type.pass.cpp
index 4303b95166c7..f4c106014a15 100644
--- a/test/std/utilities/allocator.adaptor/allocator.adaptor.types/inner_allocator_type.pass.cpp
+++ b/test/std/utilities/allocator.adaptor/allocator.adaptor.types/inner_allocator_type.pass.cpp
@@ -7,6 +7,8 @@
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: c++98, c++03
+
 // <memory>
 
 // template <class OuterAlloc, class... InnerAllocs>
@@ -21,8 +23,6 @@
 
 int main()
 {
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
-
     static_assert((std::is_same<
         std::scoped_allocator_adaptor<A1<int>>::inner_allocator_type,
         std::scoped_allocator_adaptor<A1<int>>>::value), "");
@@ -34,6 +34,4 @@ int main()
     static_assert((std::is_same<
         std::scoped_allocator_adaptor<A1<int>, A2<int>, A3<int>>::inner_allocator_type,
         std::scoped_allocator_adaptor<A2<int>, A3<int>>>::value), "");
-
-#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 }
diff --git a/test/std/utilities/allocator.adaptor/allocator.adaptor.types/is_always_equal.pass.cpp b/test/std/utilities/allocator.adaptor/allocator.adaptor.types/is_always_equal.pass.cpp
index 90fe944125b5..f8a9ea0f9eca 100644
--- a/test/std/utilities/allocator.adaptor/allocator.adaptor.types/is_always_equal.pass.cpp
+++ b/test/std/utilities/allocator.adaptor/allocator.adaptor.types/is_always_equal.pass.cpp
@@ -7,6 +7,8 @@
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: c++98, c++03
+
 // <memory>
 
 // template <class OuterAlloc, class... InnerAllocs>
@@ -22,8 +24,6 @@
 
 int main()
 {
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
-
     // sanity checks
     static_assert( (std::is_same<
     		std::allocator_traits<A1<int>>::is_always_equal, std::false_type>::value
@@ -69,7 +69,4 @@ int main()
               std::allocator_traits<A2<int>>::is_always_equal::value &&
               std::allocator_traits<A3<int>>::is_always_equal::value)
         ), "");
-
-
-#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 }
diff --git a/test/std/utilities/allocator.adaptor/allocator.adaptor.types/propagate_on_container_copy_assignment.pass.cpp b/test/std/utilities/allocator.adaptor/allocator.adaptor.types/propagate_on_container_copy_assignment.pass.cpp
index ceb941380dc7..4c6aabe2160e 100644
--- a/test/std/utilities/allocator.adaptor/allocator.adaptor.types/propagate_on_container_copy_assignment.pass.cpp
+++ b/test/std/utilities/allocator.adaptor/allocator.adaptor.types/propagate_on_container_copy_assignment.pass.cpp
@@ -7,6 +7,8 @@
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: c++98, c++03
+
 // <memory>
 
 // template <class OuterAlloc, class... InnerAllocs>
@@ -21,8 +23,6 @@
 
 int main()
 {
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
-
     static_assert((std::is_same<
         std::scoped_allocator_adaptor<A1<int>>::propagate_on_container_copy_assignment,
         std::false_type>::value), "");
@@ -35,5 +35,4 @@ int main()
         std::scoped_allocator_adaptor<A1<int>, A2<int>, A3<int>>::propagate_on_container_copy_assignment,
         std::true_type>::value), "");
 
-#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 }
diff --git a/test/std/utilities/allocator.adaptor/allocator.adaptor.types/propagate_on_container_move_assignment.pass.cpp b/test/std/utilities/allocator.adaptor/allocator.adaptor.types/propagate_on_container_move_assignment.pass.cpp
index 04da50706536..f6f092ba575a 100644
--- a/test/std/utilities/allocator.adaptor/allocator.adaptor.types/propagate_on_container_move_assignment.pass.cpp
+++ b/test/std/utilities/allocator.adaptor/allocator.adaptor.types/propagate_on_container_move_assignment.pass.cpp
@@ -7,6 +7,8 @@
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: c++98, c++03
+
 // <memory>
 
 // template <class OuterAlloc, class... InnerAllocs>
@@ -21,8 +23,6 @@
 
 int main()
 {
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
-
     static_assert((std::is_same<
         std::scoped_allocator_adaptor<A1<int>>::propagate_on_container_move_assignment,
         std::false_type>::value), "");
@@ -35,5 +35,4 @@ int main()
         std::scoped_allocator_adaptor<A1<int>, A2<int>, A3<int>>::propagate_on_container_move_assignment,
         std::true_type>::value), "");
 
-#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 }
diff --git a/test/std/utilities/allocator.adaptor/allocator.adaptor.types/propagate_on_container_swap.pass.cpp b/test/std/utilities/allocator.adaptor/allocator.adaptor.types/propagate_on_container_swap.pass.cpp
index 4a66bbd46749..6b7273e266be 100644
--- a/test/std/utilities/allocator.adaptor/allocator.adaptor.types/propagate_on_container_swap.pass.cpp
+++ b/test/std/utilities/allocator.adaptor/allocator.adaptor.types/propagate_on_container_swap.pass.cpp
@@ -7,6 +7,8 @@
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: c++98, c++03
+
 // <memory>
 
 // template <class OuterAlloc, class... InnerAllocs>
@@ -21,8 +23,6 @@
 
 int main()
 {
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
-
     static_assert((std::is_same<
         std::scoped_allocator_adaptor<A1<int>>::propagate_on_container_swap,
         std::false_type>::value), "");
@@ -34,6 +34,4 @@ int main()
     static_assert((std::is_same<
         std::scoped_allocator_adaptor<A1<int>, A2<int>, A3<int>>::propagate_on_container_swap,
         std::true_type>::value), "");
-
-#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 }
diff --git a/test/std/utilities/allocator.adaptor/scoped.adaptor.operators/copy_assign.pass.cpp b/test/std/utilities/allocator.adaptor/scoped.adaptor.operators/copy_assign.pass.cpp
index 72f0e867b1d2..2cf548550e1f 100644
--- a/test/std/utilities/allocator.adaptor/scoped.adaptor.operators/copy_assign.pass.cpp
+++ b/test/std/utilities/allocator.adaptor/scoped.adaptor.operators/copy_assign.pass.cpp
@@ -7,6 +7,8 @@
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: c++98, c++03
+
 // <memory>
 
 // template <class OuterAlloc, class... InnerAllocs>
@@ -22,7 +24,6 @@
 
 int main()
 {
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
     {
         typedef std::scoped_allocator_adaptor<A1<int>> A;
         A a1(A1<int>(3));
@@ -68,5 +69,4 @@ int main()
         assert(A3<int>::move_called == false);
         assert(aN == a1);
     }
-#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 }
diff --git a/test/std/utilities/allocator.adaptor/scoped.adaptor.operators/eq.pass.cpp b/test/std/utilities/allocator.adaptor/scoped.adaptor.operators/eq.pass.cpp
index 51dd67f9ffdc..4f7a3af12544 100644
--- a/test/std/utilities/allocator.adaptor/scoped.adaptor.operators/eq.pass.cpp
+++ b/test/std/utilities/allocator.adaptor/scoped.adaptor.operators/eq.pass.cpp
@@ -7,6 +7,8 @@
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: c++98, c++03
+
 // <memory>
 
 // template <class OuterAlloc, class... InnerAllocs>
@@ -29,8 +31,6 @@
 
 int main()
 {
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
-
     {
         typedef std::scoped_allocator_adaptor<A1<int>> A;
         A a1(A1<int>(3));
@@ -59,6 +59,4 @@ int main()
         assert(a2 != a1);
         assert(!(a2 == a1));
     }
-
-#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 }
diff --git a/test/std/utilities/allocator.adaptor/scoped.adaptor.operators/move_assign.pass.cpp b/test/std/utilities/allocator.adaptor/scoped.adaptor.operators/move_assign.pass.cpp
index 0dc479c246c9..68f5a7ea2879 100644
--- a/test/std/utilities/allocator.adaptor/scoped.adaptor.operators/move_assign.pass.cpp
+++ b/test/std/utilities/allocator.adaptor/scoped.adaptor.operators/move_assign.pass.cpp
@@ -7,6 +7,8 @@
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: c++98, c++03
+
 // <memory>
 
 // template <class OuterAlloc, class... InnerAllocs>
@@ -22,7 +24,6 @@
 
 int main()
 {
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
     {
         typedef std::scoped_allocator_adaptor<A1<int>> A;
         A a1(A1<int>(3));
@@ -68,5 +69,4 @@ int main()
         assert(A3<int>::move_called == true);
         assert(aN == a1);
     }
-#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 }
diff --git a/test/std/utilities/allocator.adaptor/types.pass.cpp b/test/std/utilities/allocator.adaptor/types.pass.cpp
index 7beff48bbf46..fcc99b191108 100644
--- a/test/std/utilities/allocator.adaptor/types.pass.cpp
+++ b/test/std/utilities/allocator.adaptor/types.pass.cpp
@@ -7,6 +7,8 @@
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: c++98, c++03
+
 // <memory>
 
 // template <class OuterAlloc, class... InnerAllocs>
@@ -30,8 +32,6 @@
 
 int main()
 {
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
-
     static_assert((std::is_base_of<
         A1<int>,
         std::scoped_allocator_adaptor<A1<int>>
@@ -97,6 +97,4 @@ int main()
     static_assert((std::is_same<
         std::scoped_allocator_adaptor<A2<int>, A1<int>>::const_void_pointer,
         const void*>::value), "");
-
-#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 }