Gitiles
Code Review Sign In
gerrit-public.fairphone.software / platform / external / libcxx / 73d21a4f0774d3fadab98e690619a359cfb160a3 / . / test / containers / unord / unord.multimap / unord.multimap.cnstr / move_alloc.pass.cpp
blob: 8868841dbf0d05d6964f6b83388e1369acd2922b [file] [log] [blame]
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000[diff] [blame]1//===----------------------------------------------------------------------===//
2//
Howard Hinnantf5256e12010-05-11 21:36:01 +0000[diff] [blame]3// The LLVM Compiler Infrastructure
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000[diff] [blame]4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9
10// <unordered_map>
11
12// template <class Key, class T, class Hash = hash<Key>, class Pred = equal_to<Key>,
13// class Alloc = allocator<pair<const Key, T>>>
14// class unordered_multimap
15
16// unordered_multimap(unordered_multimap&& u, const allocator_type& a);
17
18#include <iostream>
19
20#include <unordered_map>
21#include <string>
22#include <cassert>
23
24#include "../../../test_compare.h"
25#include "../../../test_hash.h"
26#include "../../../test_allocator.h"
27
28int main()
29{
Howard Hinnant73d21a42010-09-04 23:28:19 +0000[diff] [blame^]30#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000[diff] [blame]31 {
32 typedef std::pair<int, std::string> P;
33 typedef test_allocator<std::pair<const int, std::string>> A;
34 typedef std::unordered_multimap<int, std::string,
35 test_hash<std::hash<int> >,
36 test_compare<std::equal_to<int> >,
37 A
38 > C;
39 P a[] =
40 {
41 P(1, "one"),
42 P(2, "two"),
43 P(3, "three"),
44 P(4, "four"),
45 P(1, "four"),
46 P(2, "four"),
47 };
48 C c0(a, a + sizeof(a)/sizeof(a[0]),
49 7,
50 test_hash<std::hash<int> >(8),
51 test_compare<std::equal_to<int> >(9),
52 A(10)
53 );
54 C c(std::move(c0), A(12));
55 assert(c.bucket_count() >= 7);
56 assert(c.size() == 6);
57 typedef std::pair<C::const_iterator, C::const_iterator> Eq;
58 Eq eq = c.equal_range(1);
59 assert(std::distance(eq.first, eq.second) == 2);
60 C::const_iterator i = eq.first;
61 assert(i->first == 1);
62 assert(i->second == "one");
63 ++i;
64 assert(i->first == 1);
65 assert(i->second == "four");
66 eq = c.equal_range(2);
67 assert(std::distance(eq.first, eq.second) == 2);
68 i = eq.first;
69 assert(i->first == 2);
70 assert(i->second == "two");
71 ++i;
72 assert(i->first == 2);
73 assert(i->second == "four");
74
75 eq = c.equal_range(3);
76 assert(std::distance(eq.first, eq.second) == 1);
77 i = eq.first;
78 assert(i->first == 3);
79 assert(i->second == "three");
80 eq = c.equal_range(4);
81 assert(std::distance(eq.first, eq.second) == 1);
82 i = eq.first;
83 assert(i->first == 4);
84 assert(i->second == "four");
85 assert(std::distance(c.begin(), c.end()) == c.size());
86 assert(std::distance(c.cbegin(), c.cend()) == c.size());
87 assert(c.load_factor() == (float)c.size()/c.bucket_count());
88 assert(c.max_load_factor() == 1);
89 assert(c.hash_function() == test_hash<std::hash<int> >(8));
90 assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
91 assert((c.get_allocator() == test_allocator<std::pair<const int, std::string> >(12)));
92
93 assert(c0.empty());
94 }
95 {
96 typedef std::pair<int, std::string> P;
97 typedef test_allocator<std::pair<const int, std::string>> A;
98 typedef std::unordered_multimap<int, std::string,
99 test_hash<std::hash<int> >,
100 test_compare<std::equal_to<int> >,
101 A
102 > C;
103 P a[] =
104 {
105 P(1, "one"),
106 P(2, "two"),
107 P(3, "three"),
108 P(4, "four"),
109 P(1, "four"),
110 P(2, "four"),
111 };
112 C c0(a, a + sizeof(a)/sizeof(a[0]),
113 7,
114 test_hash<std::hash<int> >(8),
115 test_compare<std::equal_to<int> >(9),
116 A(10)
117 );
118 C c(std::move(c0), A(10));
119 assert(c.bucket_count() == 7);
120 assert(c.size() == 6);
121 typedef std::pair<C::const_iterator, C::const_iterator> Eq;
122 Eq eq = c.equal_range(1);
123 assert(std::distance(eq.first, eq.second) == 2);
124 C::const_iterator i = eq.first;
125 assert(i->first == 1);
126 assert(i->second == "one");
127 ++i;
128 assert(i->first == 1);
129 assert(i->second == "four");
130 eq = c.equal_range(2);
131 assert(std::distance(eq.first, eq.second) == 2);
132 i = eq.first;
133 assert(i->first == 2);
134 assert(i->second == "two");
135 ++i;
136 assert(i->first == 2);
137 assert(i->second == "four");
138
139 eq = c.equal_range(3);
140 assert(std::distance(eq.first, eq.second) == 1);
141 i = eq.first;
142 assert(i->first == 3);
143 assert(i->second == "three");
144 eq = c.equal_range(4);
145 assert(std::distance(eq.first, eq.second) == 1);
146 i = eq.first;
147 assert(i->first == 4);
148 assert(i->second == "four");
149 assert(std::distance(c.begin(), c.end()) == c.size());
150 assert(std::distance(c.cbegin(), c.cend()) == c.size());
151 assert(c.load_factor() == (float)c.size()/c.bucket_count());
152 assert(c.max_load_factor() == 1);
153 assert(c.hash_function() == test_hash<std::hash<int> >(8));
154 assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
155 assert((c.get_allocator() == test_allocator<std::pair<const int, std::string> >(10)));
156
157 assert(c0.empty());
158 }
Howard Hinnant73d21a42010-09-04 23:28:19 +0000[diff] [blame^]159#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000[diff] [blame]160}