1 // Copyright (C) 2013-2018 Free Software Foundation, Inc.
2 //
3 // This file is part of the GNU ISO C++ Library. This library is free
4 // software; you can redistribute it and/or modify it under the
5 // terms of the GNU General Public License as published by the
6 // Free Software Foundation; either version 3, or (at your option)
7 // any later version.
8
9 // This library is distributed in the hope that it will be useful,
10 // but WITHOUT ANY WARRANTY; without even the implied warranty of
11 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 // GNU General Public License for more details.
13
14 // You should have received a copy of the GNU General Public License along
15 // with this library; see the file COPYING3. If not see
16 // <http://www.gnu.org/licenses/>.
17
18 // { dg-do run { target c++11 } }
19
20 #include <unordered_map>
21 #include <testsuite_hooks.h>
22 #include <testsuite_allocator.h>
23
24 struct T { int i; };
25
26 struct hash
27 {
operator ()hash28 std::size_t operator()(const T t) const noexcept
29 { return t.i; }
30 };
31
32 struct equal_to
33 {
operator ()equal_to34 bool operator()(const T& lhs, const T& rhs) const noexcept
35 { return lhs.i == rhs.i; }
36 };
37
38 using __gnu_test::propagating_allocator;
39
40 // It is undefined behaviour to swap() containers wth unequal allocators
41 // if the allocator doesn't propagate, so ensure the allocators compare
42 // equal, while still being able to test propagation via get_personality().
43 bool
operator ==(const propagating_allocator<std::pair<const T,T>,false> &,const propagating_allocator<std::pair<const T,T>,false> &)44 operator==(const propagating_allocator<std::pair<const T, T>, false>&,
45 const propagating_allocator<std::pair<const T, T>, false>&)
46 {
47 return true;
48 }
49
50 bool
operator !=(const propagating_allocator<std::pair<const T,T>,false> &,const propagating_allocator<std::pair<const T,T>,false> &)51 operator!=(const propagating_allocator<std::pair<const T, T>, false>&,
52 const propagating_allocator<std::pair<const T, T>, false>&)
53 {
54 return false;
55 }
56
test01()57 void test01()
58 {
59 typedef propagating_allocator<std::pair<const T, T>, false> alloc_type;
60 typedef std::unordered_map<T, T, hash, equal_to, alloc_type> test_type;
61 test_type v1(alloc_type(1));
62 v1.emplace(std::piecewise_construct,
63 std::make_tuple(T()), std::make_tuple(T()));
64 test_type v2(alloc_type(2));
65 v2.emplace(std::piecewise_construct,
66 std::make_tuple(T()), std::make_tuple(T()));
67 std::swap(v1, v2);
68 VERIFY(1 == v1.get_allocator().get_personality());
69 VERIFY(2 == v2.get_allocator().get_personality());
70 // swap back so assertions in uneq_allocator::deallocate don't fail
71 std::swap(v1, v2);
72 }
73
test02()74 void test02()
75 {
76 typedef propagating_allocator<std::pair<const T, T>, true> alloc_type;
77 typedef std::unordered_map<T, T, hash, equal_to, alloc_type> test_type;
78 test_type v1(alloc_type(1));
79 v1.emplace(std::piecewise_construct,
80 std::make_tuple(T()), std::make_tuple(T()));
81 test_type v2(alloc_type(2));
82 v2.emplace(std::piecewise_construct,
83 std::make_tuple(T()), std::make_tuple(T()));
84 std::swap(v1, v2);
85 VERIFY(2 == v1.get_allocator().get_personality());
86 VERIFY(1 == v2.get_allocator().get_personality());
87 }
88
main()89 int main()
90 {
91 test01();
92 test02();
93 return 0;
94 }
95