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