[libcxx][test][NFC] Extend get_allocator() testing for containers

[kboyarinov]

Summary

Add separate tests for get_allocator() method for sequence, ordered and unordered associative containers.
Current tests are intended to test postcondition of constructors that accepts allocator.
Also, new tests covers constancy of the method.

[ldionne]

Thanks a lot for improving the tests! I have some comments, but LGTM otherwise.

libcxx/test/std/containers/associative/map/get_allocator.pass.cpp

24

Suggestion -- in these tests, you could use typedef std::pair<const int, std::string> Pair to make things a little bit less verbose.

29

Just curious, but why are those only enabled in C++11 and later? What is C++11 specific about those?

33

This is going to be needed for the test to pass in C++03 mode (applies elsewhere too).

[kboyarinov]

Added type aliases for associative containers value_types.
Removed C++11 mode for other_allocator
Fixed C++03

[kboyarinov]

libcxx/test/std/containers/associative/map/get_allocator.pass.cpp

29

You are right, there is no specific C++11 code here, I confused other_allocator with min_allocator, which is wrapped into C++11 macros everywhere. Thank you!

[Mordante]

Thanks for working on this! LGTM!

[rarutyun]

LGTM

libcxx/test/std/containers/associative/map/get_allocator.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// 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**) {
+    typedef std::pair<const int, std::string> ValueType;
+    {
+        std::allocator<ValueType> alloc;
+        const std::map<int, std::string> m(alloc);
+        assert(m.get_allocator() == alloc);
+    }
+    {
+        other_allocator<ValueType> alloc(1);
+        const std::map<int, std::string, std::less<int>,
+                       other_allocator<ValueType> > m(alloc);
+        assert(m.get_allocator() == alloc);
+    }
+
+    return 0;
+}

libcxx/test/std/containers/associative/multimap/get_allocator.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// 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**) {
+    typedef std::pair<const int, std::string> ValueType;
+    {
+        std::allocator<ValueType> alloc;
+        const std::multimap<int, std::string> m(alloc);
+        assert(m.get_allocator() == alloc);
+    }
+    {
+        other_allocator<ValueType> alloc(1);
+        const std::multimap<int, std::string, std::less<int>,
+                            other_allocator<ValueType> > m(alloc);
+        assert(m.get_allocator() == alloc);
+    }
+
+    return 0;
+}

libcxx/test/std/containers/associative/multiset/get_allocator.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// 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);
+    }
+    {
+        other_allocator<int> alloc(1);
+        const std::multiset<int, std::less<int>, other_allocator<int> > s(alloc);
+        assert(s.get_allocator() == alloc);
+    }
+    return 0;
+}

libcxx/test/std/containers/associative/set/get_allocator.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// 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);
+    }
+    {
+        other_allocator<int> alloc(1);
+        const std::set<int, std::less<int>, other_allocator<int> > s(alloc);
+        assert(s.get_allocator() == alloc);
+    }
+    return 0;
+}

libcxx/test/std/containers/sequences/deque/get_allocator.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// 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);
+    }
+    {
+        other_allocator<int> alloc(1);
+        const std::deque<int, other_allocator<int> > d(alloc);
+        assert(d.get_allocator() == alloc);
+    }
+
+    return 0;
+}

libcxx/test/std/containers/sequences/forwardlist/get_allocator.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// 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);
+    }
+    {
+        other_allocator<int> alloc(1);
+        const std::forward_list<int, other_allocator<int> > fl(alloc);
+        assert(fl.get_allocator() == alloc);
+    }
+
+    return 0;
+}

libcxx/test/std/containers/sequences/list/get_allocator.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// 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);
+    }
+    {
+        other_allocator<int> alloc(1);
+        const std::list<int, other_allocator<int> > l(alloc);
+        assert(l.get_allocator() == alloc);
+    }
+
+    return 0;
+}

libcxx/test/std/containers/sequences/vector.bool/get_allocator.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// 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);
+    }
+    {
+        other_allocator<int> alloc(1);
+        const std::vector<bool, other_allocator<int> > vb(alloc);
+        assert(vb.get_allocator() == alloc);
+    }
+
+    return 0;
+}

libcxx/test/std/containers/sequences/vector/get_allocator.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// 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> v(alloc);
+        assert(v.get_allocator() == alloc);
+    }
+    {
+        other_allocator<int> alloc(1);
+        const std::vector<int, other_allocator<int> > v(alloc);
+        assert(v.get_allocator() == alloc);
+    }
+
+    return 0;
+}

libcxx/test/std/containers/unord/unord.map/get_allocator.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// 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**) {
+    typedef std::pair<const int, std::string> ValueType;
+    {
+        std::allocator<ValueType> alloc;
+        const std::unordered_map<int, std::string> m(alloc);
+        assert(m.get_allocator() == alloc);
+    }
+    {
+        other_allocator<ValueType> alloc(1);
+        const std::unordered_map<int, std::string, std::hash<int>,
+                                 std::equal_to<int>,
+                                 other_allocator<ValueType> > m(alloc);
+        assert(m.get_allocator() == alloc);
+    }
+
+    return 0;
+}

libcxx/test/std/containers/unord/unord.multimap/get_allocator.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// 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**) {
+    typedef std::pair<const int, std::string> ValueType;
+    {
+        std::allocator<ValueType> alloc;
+        const std::unordered_multimap<int, std::string> m(alloc);
+        assert(m.get_allocator() == alloc);
+    }
+    {
+        other_allocator<ValueType> alloc(1);
+        const std::unordered_multimap<int, std::string, std::hash<int>,
+                                      std::equal_to<int>,
+                                      other_allocator<ValueType> > m(alloc);
+        assert(m.get_allocator() == alloc);
+    }
+
+    return 0;
+}

libcxx/test/std/containers/unord/unord.multiset/get_allocator.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// 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);
+    }
+    {
+        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);
+    }
+
+    return 0;
+}

libcxx/test/std/containers/unord/unord.set/get_allocator.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// 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);
+    }
+    {
+        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);
+    }
+
+    return 0;
+}