1 //===----------------------------------------------------------------------===//
2 //
3 //                     The LLVM Compiler Infrastructure
4 //
5 // This file is dual licensed under the MIT and the University of Illinois Open
6 // Source Licenses. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 
10 // <unordered_set>
11 
12 // template <class Value, class Hash = hash<Value>, class Pred = equal_to<Value>,
13 //           class Alloc = allocator<Value>>
14 // class unordered_multiset
15 
16 // unordered_multiset(initializer_list<value_type> il, size_type n);
17 
18 #include <unordered_set>
19 #include <cassert>
20 #include <cfloat>
21 
22 #include "../../../test_compare.h"
23 #include "../../../test_hash.h"
24 #include "../../../test_allocator.h"
25 #include "../../../min_allocator.h"
26 
27 int main()
28 {
29 #ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
30     {
31         typedef std::unordered_multiset<int,
32                                    test_hash<std::hash<int> >,
33                                    test_compare<std::equal_to<int> >,
34                                    test_allocator<int>
35                                    > C;
36         typedef int P;
37         C c({
38                 P(1),
39                 P(2),
40                 P(3),
41                 P(4),
42                 P(1),
43                 P(2)
44             },
45             7
46            );
47         assert(c.bucket_count() == 7);
48         assert(c.size() == 6);
49         assert(c.count(1) == 2);
50         assert(c.count(2) == 2);
51         assert(c.count(3) == 1);
52         assert(c.count(4) == 1);
53         assert(c.hash_function() == test_hash<std::hash<int> >());
54         assert(c.key_eq() == test_compare<std::equal_to<int> >());
55         assert(c.get_allocator() == test_allocator<int>());
56         assert(!c.empty());
57         assert(std::distance(c.begin(), c.end()) == c.size());
58         assert(std::distance(c.cbegin(), c.cend()) == c.size());
59         assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
60         assert(c.max_load_factor() == 1);
61     }
62 #if __cplusplus >= 201103L
63     {
64         typedef std::unordered_multiset<int,
65                                    test_hash<std::hash<int> >,
66                                    test_compare<std::equal_to<int> >,
67                                    min_allocator<int>
68                                    > C;
69         typedef int P;
70         C c({
71                 P(1),
72                 P(2),
73                 P(3),
74                 P(4),
75                 P(1),
76                 P(2)
77             },
78             7
79            );
80         assert(c.bucket_count() == 7);
81         assert(c.size() == 6);
82         assert(c.count(1) == 2);
83         assert(c.count(2) == 2);
84         assert(c.count(3) == 1);
85         assert(c.count(4) == 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() == min_allocator<int>());
89         assert(!c.empty());
90         assert(std::distance(c.begin(), c.end()) == c.size());
91         assert(std::distance(c.cbegin(), c.cend()) == c.size());
92         assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
93         assert(c.max_load_factor() == 1);
94     }
95 #endif
96 #endif  // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
97 }
98