Gitiles
Code Review Sign In
gerrit-public.fairphone.software / platform / external / libcxx / 1d4a1edbc7e4461b59239e1b8297e9dd395a6322 / . / test / std / containers / unord / unord.multimap / unord.multimap.cnstr / init_size_hash_equal.pass.cpp
blob: 095e9c327f0e9999a6d0c7c78ff11182e65e267b [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//
Howard Hinnantb64f8b02010-11-16 22:09:02 +0000[diff] [blame]5// This file is dual licensed under the MIT and the University of Illinois Open
6// Source Licenses. See LICENSE.TXT for details.
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000[diff] [blame]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(initializer_list<value_type> il, size_type n,
17// const hasher& hf, const key_equal& eql);
18
19#include <unordered_map>
20#include <string>
21#include <cassert>
Howard Hinnantf836d532011-12-02 21:23:14 +0000[diff] [blame]22#include <cfloat>
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000[diff] [blame]23
24#include "../../../test_compare.h"
25#include "../../../test_hash.h"
Marshall Clow1b921882013-12-03 00:18:10 +0000[diff] [blame]26#include "test_allocator.h"
Marshall Clow061d0cc2013-11-26 20:58:02 +0000[diff] [blame]27#include "min_allocator.h"
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000[diff] [blame]28
29int main()
30{
Howard Hinnante3e32912011-08-12 21:56:02 +0000[diff] [blame]31#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000[diff] [blame]32 {
33 typedef std::unordered_multimap<int, std::string,
34 test_hash<std::hash<int> >,
35 test_compare<std::equal_to<int> >,
36 test_allocator<std::pair<const int, std::string> >
37 > C;
38 typedef std::pair<int, std::string> P;
39 C c({
40 P(1, "one"),
41 P(2, "two"),
42 P(3, "three"),
43 P(4, "four"),
44 P(1, "four"),
45 P(2, "four"),
46 },
47 7,
48 test_hash<std::hash<int> >(8),
49 test_compare<std::equal_to<int> >(9)
50 );
51 assert(c.bucket_count() == 7);
52 assert(c.size() == 6);
53 typedef std::pair<C::const_iterator, C::const_iterator> Eq;
54 Eq eq = c.equal_range(1);
55 assert(std::distance(eq.first, eq.second) == 2);
56 C::const_iterator i = eq.first;
57 assert(i->first == 1);
58 assert(i->second == "one");
59 ++i;
60 assert(i->first == 1);
61 assert(i->second == "four");
62 eq = c.equal_range(2);
63 assert(std::distance(eq.first, eq.second) == 2);
64 i = eq.first;
65 assert(i->first == 2);
66 assert(i->second == "two");
67 ++i;
68 assert(i->first == 2);
69 assert(i->second == "four");
70
71 eq = c.equal_range(3);
72 assert(std::distance(eq.first, eq.second) == 1);
73 i = eq.first;
74 assert(i->first == 3);
75 assert(i->second == "three");
76 eq = c.equal_range(4);
77 assert(std::distance(eq.first, eq.second) == 1);
78 i = eq.first;
79 assert(i->first == 4);
80 assert(i->second == "four");
81 assert(std::distance(c.begin(), c.end()) == c.size());
82 assert(std::distance(c.cbegin(), c.cend()) == c.size());
Dan Albert1d4a1ed2016-05-25 22:36:09 -0700[diff] [blame^]83 assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000[diff] [blame]84 assert(c.max_load_factor() == 1);
85 assert(c.hash_function() == test_hash<std::hash<int> >(8));
86 assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
87 assert((c.get_allocator() == test_allocator<std::pair<const int, std::string> >()));
88 }
Howard Hinnant7a6b7ce2013-06-22 15:21:29 +0000[diff] [blame]89#if __cplusplus >= 201103L
90 {
91 typedef std::unordered_multimap<int, std::string,
92 test_hash<std::hash<int> >,
93 test_compare<std::equal_to<int> >,
94 min_allocator<std::pair<const int, std::string> >
95 > C;
96 typedef std::pair<int, std::string> P;
97 C c({
98 P(1, "one"),
99 P(2, "two"),
100 P(3, "three"),
101 P(4, "four"),
102 P(1, "four"),
103 P(2, "four"),
104 },
105 7,
106 test_hash<std::hash<int> >(8),
107 test_compare<std::equal_to<int> >(9)
108 );
109 assert(c.bucket_count() == 7);
110 assert(c.size() == 6);
111 typedef std::pair<C::const_iterator, C::const_iterator> Eq;
112 Eq eq = c.equal_range(1);
113 assert(std::distance(eq.first, eq.second) == 2);
114 C::const_iterator i = eq.first;
115 assert(i->first == 1);
116 assert(i->second == "one");
117 ++i;
118 assert(i->first == 1);
119 assert(i->second == "four");
120 eq = c.equal_range(2);
121 assert(std::distance(eq.first, eq.second) == 2);
122 i = eq.first;
123 assert(i->first == 2);
124 assert(i->second == "two");
125 ++i;
126 assert(i->first == 2);
127 assert(i->second == "four");
128
129 eq = c.equal_range(3);
130 assert(std::distance(eq.first, eq.second) == 1);
131 i = eq.first;
132 assert(i->first == 3);
133 assert(i->second == "three");
134 eq = c.equal_range(4);
135 assert(std::distance(eq.first, eq.second) == 1);
136 i = eq.first;
137 assert(i->first == 4);
138 assert(i->second == "four");
139 assert(std::distance(c.begin(), c.end()) == c.size());
140 assert(std::distance(c.cbegin(), c.cend()) == c.size());
Dan Albert1d4a1ed2016-05-25 22:36:09 -0700[diff] [blame^]141 assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
Howard Hinnant7a6b7ce2013-06-22 15:21:29 +0000[diff] [blame]142 assert(c.max_load_factor() == 1);
143 assert(c.hash_function() == test_hash<std::hash<int> >(8));
144 assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
145 assert((c.get_allocator() == min_allocator<std::pair<const int, std::string> >()));
146 }
147#endif
Howard Hinnante3e32912011-08-12 21:56:02 +0000[diff] [blame]148#endif // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000[diff] [blame]149}