Index: libcxx/test/std/containers/associative/map/get_allocator.pass.cpp
===================================================================
--- /dev/null
+++ libcxx/test/std/containers/associative/map/get_allocator.pass.cpp
@@ -0,0 +1,37 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// <map>
+
+// class map
+
+// allocator_type get_allocator() const
+
+#include <map>
+#include <cassert>
+#include <string>
+
+#include "test_allocator.h"
+#include "test_macros.h"
+
+int main(int, char**) {
+    {
+        std::allocator<std::pair<const int, std::string> > alloc;
+        const std::map<int, std::string> m(alloc);
+        assert(m.get_allocator() == alloc);
+    }
+#if TEST_STD_VER >= 11
+    {
+        other_allocator<std::pair<const int, std::string> > alloc(1);
+        const std::map<int, std::string, std::less<int>,
+                       other_allocator<std::pair<const int, std::string>>> m(alloc);
+        assert(m.get_allocator() == alloc);
+    }
+#endif
+    return 0;
+}
Index: libcxx/test/std/containers/associative/multimap/get_allocator.pass.cpp
===================================================================
--- /dev/null
+++ libcxx/test/std/containers/associative/multimap/get_allocator.pass.cpp
@@ -0,0 +1,37 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// <map>
+
+// class multimap
+
+// allocator_type get_allocator() const
+
+#include <map>
+#include <cassert>
+#include <string>
+
+#include "test_allocator.h"
+#include "test_macros.h"
+
+int main(int, char**) {
+    {
+        std::allocator<std::pair<const int, std::string> > alloc;
+        const std::multimap<int, std::string> m(alloc);
+        assert(m.get_allocator() == alloc);
+    }
+#if TEST_STD_VER >= 11
+    {
+        other_allocator<std::pair<const int, std::string> > alloc(1);
+        const std::multimap<int, std::string, std::less<int>,
+                            other_allocator<std::pair<const int, std::string>>> m(alloc);
+        assert(m.get_allocator() == alloc);
+    }
+#endif
+    return 0;
+}
Index: libcxx/test/std/containers/associative/multiset/get_allocator.pass.cpp
===================================================================
--- /dev/null
+++ libcxx/test/std/containers/associative/multiset/get_allocator.pass.cpp
@@ -0,0 +1,35 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// <set>
+
+// class multiset
+
+// allocator_type get_allocator() const
+
+#include <set>
+#include <cassert>
+
+#include "test_allocator.h"
+#include "test_macros.h"
+
+int main(int, char**) {
+    {
+        std::allocator<int> alloc;
+        const std::multiset<int> s(alloc);
+        assert(s.get_allocator() == alloc);
+    }
+#if TEST_STD_VER >= 11
+    {
+        other_allocator<int> alloc(1);
+        const std::multiset<int, std::less<int>, other_allocator<int>> s(alloc);
+        assert(s.get_allocator() == alloc);
+    }
+#endif
+    return 0;
+}
Index: libcxx/test/std/containers/associative/set/get_allocator.pass.cpp
===================================================================
--- /dev/null
+++ libcxx/test/std/containers/associative/set/get_allocator.pass.cpp
@@ -0,0 +1,35 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// <set>
+
+// class set
+
+// allocator_type get_allocator() const
+
+#include <set>
+#include <cassert>
+
+#include "test_allocator.h"
+#include "test_macros.h"
+
+int main(int, char**) {
+    {
+        std::allocator<int> alloc;
+        const std::set<int> s(alloc);
+        assert(s.get_allocator() == alloc);
+    }
+#if TEST_STD_VER >= 11
+    {
+        other_allocator<int> alloc(1);
+        const std::set<int, std::less<int>, other_allocator<int>> s(alloc);
+        assert(s.get_allocator() == alloc);
+    }
+#endif
+    return 0;
+}
Index: libcxx/test/std/containers/sequences/deque/get_allocator.pass.cpp
===================================================================
--- /dev/null
+++ libcxx/test/std/containers/sequences/deque/get_allocator.pass.cpp
@@ -0,0 +1,35 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// <deque>
+
+// class deque
+
+// allocator_type get_allocator() const
+
+#include <deque>
+#include <cassert>
+
+#include "test_allocator.h"
+#include "test_macros.h"
+
+int main(int, char**) {
+    {
+        std::allocator<int> alloc;
+        const std::deque<int> d(alloc);
+        assert(d.get_allocator() == alloc);
+    }
+#if TEST_STD_VER >= 11
+    {
+        other_allocator<int> alloc(1);
+        const std::deque<int, other_allocator<int> > d(alloc);
+        assert(d.get_allocator() == alloc);
+    }
+#endif
+    return 0;
+}
Index: libcxx/test/std/containers/sequences/forwardlist/get_allocator.pass.cpp
===================================================================
--- /dev/null
+++ libcxx/test/std/containers/sequences/forwardlist/get_allocator.pass.cpp
@@ -0,0 +1,35 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// <forward_list>
+
+// class forward_list
+
+// allocator_type get_allocator() const
+
+#include <forward_list>
+#include <cassert>
+
+#include "test_allocator.h"
+#include "test_macros.h"
+
+int main(int, char**) {
+    {
+        std::allocator<int> alloc;
+        const std::forward_list<int> fl(alloc);
+        assert(fl.get_allocator() == alloc);
+    }
+#if TEST_STD_VER >= 11
+    {
+        other_allocator<int> alloc(1);
+        const std::forward_list<int, other_allocator<int>> fl(alloc);
+        assert(fl.get_allocator() == alloc);
+    }
+#endif
+    return 0;
+}
Index: libcxx/test/std/containers/sequences/list/get_allocator.pass.cpp
===================================================================
--- /dev/null
+++ libcxx/test/std/containers/sequences/list/get_allocator.pass.cpp
@@ -0,0 +1,35 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// <list>
+
+// class list
+
+// allocator_type get_allocator() const
+
+#include <list>
+#include <cassert>
+
+#include "test_allocator.h"
+#include "test_macros.h"
+
+int main(int, char**) {
+    {
+        std::allocator<int> alloc;
+        const std::list<int> l(alloc);
+        assert(l.get_allocator() == alloc);
+    }
+#if TEST_STD_VER >= 11
+    {
+        other_allocator<int> alloc(1);
+        const std::list<int, other_allocator<int>> l(alloc);
+        assert(l.get_allocator() == alloc);
+    }
+#endif
+    return 0;
+}
Index: libcxx/test/std/containers/sequences/vector.bool/get_allocator.pass.cpp
===================================================================
--- /dev/null
+++ libcxx/test/std/containers/sequences/vector.bool/get_allocator.pass.cpp
@@ -0,0 +1,35 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// <vector>
+
+// class vector<bool>
+
+// allocator_type get_allocator() const
+
+#include <vector>
+#include <cassert>
+
+#include "test_allocator.h"
+#include "test_macros.h"
+
+int main(int, char**) {
+    {
+        std::allocator<int> alloc;
+        const std::vector<bool> vb(alloc);
+        assert(vb.get_allocator() == alloc);
+    }
+#if TEST_STD_VER >= 11
+    {
+        other_allocator<int> alloc(1);
+        const std::vector<bool, other_allocator<int>> vb(alloc);
+        assert(vb.get_allocator() == alloc);
+    }
+#endif
+    return 0;
+}
Index: libcxx/test/std/containers/sequences/vector/get_allocator.pass.cpp
===================================================================
--- /dev/null
+++ libcxx/test/std/containers/sequences/vector/get_allocator.pass.cpp
@@ -0,0 +1,35 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// <vector>
+
+// class vector
+
+// allocator_type get_allocator() const
+
+#include <vector>
+#include <cassert>
+
+#include "test_allocator.h"
+#include "test_macros.h"
+
+int main(int, char**) {
+    {
+        std::allocator<int> alloc;
+        const std::vector<int> vb(alloc);
+        assert(vb.get_allocator() == alloc);
+    }
+#if TEST_STD_VER >= 11
+    {
+        other_allocator<int> alloc(1);
+        const std::vector<int, other_allocator<int>> vb(alloc);
+        assert(vb.get_allocator() == alloc);
+    }
+#endif
+    return 0;
+}
Index: libcxx/test/std/containers/unord/unord.map/get_allocator.pass.cpp
===================================================================
--- /dev/null
+++ libcxx/test/std/containers/unord/unord.map/get_allocator.pass.cpp
@@ -0,0 +1,38 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// <unordered_map>
+
+// class unordered_map
+
+// allocator_type get_allocator() const
+
+#include <unordered_map>
+#include <cassert>
+#include <string>
+
+#include "test_allocator.h"
+#include "test_macros.h"
+
+int main(int, char**) {
+    {
+        std::allocator<std::pair<const int, std::string> > alloc;
+        const std::unordered_map<int, std::string> m(alloc);
+        assert(m.get_allocator() == alloc);
+    }
+#if TEST_STD_VER >= 11
+    {
+        other_allocator<std::pair<const int, std::string>> alloc(1);
+        const std::unordered_map<int, std::string, std::hash<int>,
+                                 std::equal_to<int>,
+                                 other_allocator<std::pair<const int, std::string>>> m(alloc);
+        assert(m.get_allocator() == alloc);
+    }
+#endif
+    return 0;
+}
Index: libcxx/test/std/containers/unord/unord.multimap/get_allocator.pass.cpp
===================================================================
--- /dev/null
+++ libcxx/test/std/containers/unord/unord.multimap/get_allocator.pass.cpp
@@ -0,0 +1,38 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// <unordered_map>
+
+// class unordered_multimap
+
+// allocator_type get_allocator() const
+
+#include <unordered_map>
+#include <cassert>
+#include <string>
+
+#include "test_allocator.h"
+#include "test_macros.h"
+
+int main(int, char**) {
+    {
+        std::allocator<std::pair<const int, std::string> > alloc;
+        const std::unordered_multimap<int, std::string> m(alloc);
+        assert(m.get_allocator() == alloc);
+    }
+#if TEST_STD_VER >= 11
+    {
+        other_allocator<std::pair<const int, std::string>> alloc(1);
+        const std::unordered_multimap<int, std::string, std::hash<int>,
+                                      std::equal_to<int>,
+                                      other_allocator<std::pair<const int, std::string>>> m(alloc);
+        assert(m.get_allocator() == alloc);
+    }
+#endif
+    return 0;
+}
Index: libcxx/test/std/containers/unord/unord.multiset/get_allocator.pass.cpp
===================================================================
--- /dev/null
+++ libcxx/test/std/containers/unord/unord.multiset/get_allocator.pass.cpp
@@ -0,0 +1,37 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// <unordered_set>
+
+// class unordered_multiset
+
+// allocator_type get_allocator() const
+
+#include <unordered_set>
+#include <cassert>
+
+#include "test_allocator.h"
+#include "test_macros.h"
+
+int main(int, char**) {
+    {
+        std::allocator<int> alloc;
+        const std::unordered_multiset<int> s(alloc);
+        assert(s.get_allocator() == alloc);
+    }
+#if TEST_STD_VER >= 11
+    {
+        other_allocator<int> alloc(1);
+        const std::unordered_multiset<int, std::hash<int>,
+                                      std::equal_to<int>,
+                                      other_allocator<int>> s(alloc);
+        assert(s.get_allocator() == alloc);
+    }
+#endif
+    return 0;
+}
Index: libcxx/test/std/containers/unord/unord.set/get_allocator.pass.cpp
===================================================================
--- /dev/null
+++ libcxx/test/std/containers/unord/unord.set/get_allocator.pass.cpp
@@ -0,0 +1,37 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// <unordered_set>
+
+// class unordered_set
+
+// allocator_type get_allocator() const
+
+#include <unordered_set>
+#include <cassert>
+
+#include "test_allocator.h"
+#include "test_macros.h"
+
+int main(int, char**) {
+    {
+        std::allocator<int> alloc;
+        const std::unordered_set<int> s(alloc);
+        assert(s.get_allocator() == alloc);
+    }
+#if TEST_STD_VER >= 11
+    {
+        other_allocator<int> alloc(1);
+        const std::unordered_set<int, std::hash<int>,
+                                 std::equal_to<int>,
+                                 other_allocator<int>> s(alloc);
+        assert(s.get_allocator() == alloc);
+    }
+#endif
+    return 0;
+}