Gitiles
Code Review Sign In
gerrit-public.fairphone.software / platform / external / libcxx / 1d4a1edbc7e4461b59239e1b8297e9dd395a6322 / . / test / std / containers / unord / unord.multimap / unord.multimap.modifiers / insert_rvalue.pass.cpp
blob: 5a98467e9d0f72817cb5b28b6d5fcc98415799a3 [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 P,
17// class = typename enable_if<is_convertible<P, value_type>::value>::type>
18// iterator insert(P&& x);
19
20#include <unordered_map>
21#include <cassert>
22
Marshall Clowdf00d5e2015-01-28 21:22:53 +0000[diff] [blame]23#include "MoveOnly.h"
Marshall Clow061d0cc2013-11-26 20:58:02 +0000[diff] [blame]24#include "min_allocator.h"
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000[diff] [blame]25
26int main()
27{
28 {
29 typedef std::unordered_multimap<double, int> C;
30 typedef C::iterator R;
31 typedef std::pair<double, short> P;
32 C c;
33 R r = c.insert(P(3.5, 3));
34 assert(c.size() == 1);
35 assert(r->first == 3.5);
36 assert(r->second == 3);
37
38 r = c.insert(P(3.5, 4));
39 assert(c.size() == 2);
40 assert(r->first == 3.5);
41 assert(r->second == 4);
42
43 r = c.insert(P(4.5, 4));
44 assert(c.size() == 3);
45 assert(r->first == 4.5);
46 assert(r->second == 4);
47
48 r = c.insert(P(5.5, 4));
49 assert(c.size() == 4);
50 assert(r->first == 5.5);
51 assert(r->second == 4);
52 }
Dan Albert1d4a1ed2016-05-25 22:36:09 -0700[diff] [blame^]53#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000[diff] [blame]54 {
55 typedef std::unordered_multimap<MoveOnly, MoveOnly> C;
56 typedef C::iterator R;
57 typedef std::pair<MoveOnly, MoveOnly> P;
58 C c;
59 R r = c.insert(P(3, 3));
60 assert(c.size() == 1);
61 assert(r->first == 3);
62 assert(r->second == 3);
63
64 r = c.insert(P(3, 4));
65 assert(c.size() == 2);
66 assert(r->first == 3);
67 assert(r->second == 4);
68
69 r = c.insert(P(4, 4));
70 assert(c.size() == 3);
71 assert(r->first == 4);
72 assert(r->second == 4);
73
74 r = c.insert(P(5, 4));
75 assert(c.size() == 4);
76 assert(r->first == 5);
77 assert(r->second == 4);
78 }
Dan Albert1d4a1ed2016-05-25 22:36:09 -0700[diff] [blame^]79#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
80#if __cplusplus >= 201103L
Howard Hinnant7a6b7ce2013-06-22 15:21:29 +0000[diff] [blame]81 {
82 typedef std::unordered_multimap<double, int, std::hash<double>, std::equal_to<double>,
83 min_allocator<std::pair<const double, int>>> C;
84 typedef C::iterator R;
85 typedef std::pair<double, short> P;
86 C c;
87 R r = c.insert(P(3.5, 3));
88 assert(c.size() == 1);
89 assert(r->first == 3.5);
90 assert(r->second == 3);
91
92 r = c.insert(P(3.5, 4));
93 assert(c.size() == 2);
94 assert(r->first == 3.5);
95 assert(r->second == 4);
96
97 r = c.insert(P(4.5, 4));
98 assert(c.size() == 3);
99 assert(r->first == 4.5);
100 assert(r->second == 4);
101
102 r = c.insert(P(5.5, 4));
103 assert(c.size() == 4);
104 assert(r->first == 5.5);
105 assert(r->second == 4);
106 }
Dan Albert1d4a1ed2016-05-25 22:36:09 -0700[diff] [blame^]107#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
Howard Hinnant7a6b7ce2013-06-22 15:21:29 +0000[diff] [blame]108 {
109 typedef std::unordered_multimap<MoveOnly, MoveOnly, std::hash<MoveOnly>, std::equal_to<MoveOnly>,
110 min_allocator<std::pair<const MoveOnly, MoveOnly>>> C;
111 typedef C::iterator R;
112 typedef std::pair<MoveOnly, MoveOnly> P;
113 C c;
114 R r = c.insert(P(3, 3));
115 assert(c.size() == 1);
116 assert(r->first == 3);
117 assert(r->second == 3);
118
119 r = c.insert(P(3, 4));
120 assert(c.size() == 2);
121 assert(r->first == 3);
122 assert(r->second == 4);
123
124 r = c.insert(P(4, 4));
125 assert(c.size() == 3);
126 assert(r->first == 4);
127 assert(r->second == 4);
128
129 r = c.insert(P(5, 4));
130 assert(c.size() == 4);
131 assert(r->first == 5);
132 assert(r->second == 4);
133 }
Dan Albert1d4a1ed2016-05-25 22:36:09 -0700[diff] [blame^]134#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
135#endif
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000[diff] [blame]136}